@neocompose/cli 0.22.7 → 0.23.1

package/dist/neo.mjs

@@ -28857,6 +28857,316 @@ var init_contracts = __esm({
   }
 });
 
+// src/project-sync/merge.ts
+function threeWayMergeRecord(base, server, local, policy = {}) {
+  const baseRecord = isObjectRecord2(base) ? base : {};
+  const serverRecord = isObjectRecord2(server) ? server : {};
+  const localRecord = isObjectRecord2(local) ? local : {};
+  const comparisonBase = policy.comparison?.base ?? baseRecord;
+  const comparisonServer = policy.comparison?.server ?? serverRecord;
+  const comparisonLocal = policy.comparison?.local ?? localRecord;
+  const merged = {};
+  const conflictFields = [];
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(serverRecord),
+    ...Object.keys(localRecord),
+    ...Object.keys(baseRecord)
+  ]);
+  for (const key of keys) {
+    const rawServerValue = serverRecord[key];
+    const rawLocalValue = localRecord[key];
+    if (policy.serverWinsFields?.has(key) === true) {
+      if (rawServerValue !== void 0) merged[key] = rawServerValue;
+      continue;
+    }
+    const baseValue = comparisonBase[key];
+    const serverValue = comparisonServer[key];
+    const localValue = comparisonLocal[key];
+    const result = mergeValue({
+      rawBase: baseRecord[key],
+      rawServer: rawServerValue,
+      rawLocal: rawLocalValue,
+      base: baseValue,
+      server: serverValue,
+      local: localValue,
+      path: key,
+      recursive: policy.recursive === true
+    });
+    if (result.conflicts.length > 0) {
+      conflictFields.push(...result.conflicts);
+    } else if (result.present) {
+      merged[key] = result.value;
+    }
+  }
+  return { merged, conflictFields };
+}
+function mergeValue(args) {
+  if (canonicallyEqual(args.server, args.base)) {
+    return selected(args.rawLocal);
+  }
+  if (canonicallyEqual(args.local, args.base)) {
+    return selected(args.rawServer);
+  }
+  if (canonicallyEqual(args.local, args.server)) {
+    return selected(args.rawLocal);
+  }
+  if (!args.recursive) return conflict(args.path);
+  if (isObjectRecord2(args.rawBase) && isObjectRecord2(args.rawServer) && isObjectRecord2(args.rawLocal)) {
+    const comparisonBase = isObjectRecord2(args.base) ? args.base : args.rawBase;
+    const comparisonServer = isObjectRecord2(args.server) ? args.server : args.rawServer;
+    const comparisonLocal = isObjectRecord2(args.local) ? args.local : args.rawLocal;
+    const value = {};
+    const conflicts = [];
+    const keys = /* @__PURE__ */ new Set([
+      ...Object.keys(args.rawBase),
+      ...Object.keys(args.rawServer),
+      ...Object.keys(args.rawLocal)
+    ]);
+    for (const key of keys) {
+      const nested = mergeValue({
+        rawBase: args.rawBase[key],
+        rawServer: args.rawServer[key],
+        rawLocal: args.rawLocal[key],
+        base: comparisonBase[key],
+        server: comparisonServer[key],
+        local: comparisonLocal[key],
+        path: `${args.path}.${key}`,
+        recursive: true
+      });
+      conflicts.push(...nested.conflicts);
+      if (nested.present) value[key] = nested.value;
+    }
+    return { present: true, value, conflicts };
+  }
+  if (Array.isArray(args.rawBase) && Array.isArray(args.rawServer) && Array.isArray(args.rawLocal)) {
+    return mergeIdentityArray(
+      args.rawBase,
+      args.rawServer,
+      args.rawLocal,
+      args.path
+    );
+  }
+  return conflict(args.path);
+}
+function mergeIdentityArray(base, server, local, path) {
+  const baseItems = indexIdentityArray(base);
+  const serverItems = indexIdentityArray(server);
+  const localItems = indexIdentityArray(local);
+  if (baseItems === null || serverItems === null || localItems === null) {
+    return conflict(path);
+  }
+  const retained = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  const ids = /* @__PURE__ */ new Set([
+    ...baseItems.order,
+    ...serverItems.order,
+    ...localItems.order
+  ]);
+  for (const id2 of ids) {
+    const baseHas = baseItems.values.has(id2);
+    const serverHas = serverItems.values.has(id2);
+    const localHas = localItems.values.has(id2);
+    const baseValue = baseItems.values.get(id2);
+    const serverValue = serverItems.values.get(id2);
+    const localValue = localItems.values.get(id2);
+    if (baseHas && !serverHas && !localHas) continue;
+    if (baseHas && !serverHas) {
+      if (canonicallyEqual(localValue, baseValue)) continue;
+      conflicts.push(`${path}[${JSON.stringify(id2)}]`);
+      continue;
+    }
+    if (baseHas && !localHas) {
+      if (canonicallyEqual(serverValue, baseValue)) continue;
+      conflicts.push(`${path}[${JSON.stringify(id2)}]`);
+      continue;
+    }
+    if (!serverHas && localHas) {
+      retained.set(id2, localValue);
+      continue;
+    }
+    if (!localHas && serverHas) {
+      retained.set(id2, serverValue);
+      continue;
+    }
+    const merged = mergeValue({
+      rawBase: baseValue,
+      rawServer: serverValue,
+      rawLocal: localValue,
+      base: baseValue,
+      server: serverValue,
+      local: localValue,
+      path: `${path}[${JSON.stringify(id2)}]`,
+      recursive: true
+    });
+    conflicts.push(...merged.conflicts);
+    if (merged.present) retained.set(id2, merged.value);
+  }
+  if (conflicts.length > 0) return { present: true, value: [], conflicts };
+  const order = mergeIdentityOrder(
+    baseItems.order,
+    serverItems.order,
+    localItems.order,
+    new Set(retained.keys())
+  );
+  if (order === null) return conflict(`${path}.$order`);
+  return {
+    present: true,
+    value: order.map((id2) => retained.get(id2)),
+    conflicts: []
+  };
+}
+function indexIdentityArray(values) {
+  const result = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const value of values) {
+    const id2 = identityOf(value);
+    if (id2 === null || result.has(id2)) return null;
+    result.set(id2, value);
+    order.push(id2);
+  }
+  return { order, values: result };
+}
+function identityOf(value) {
+  if (typeof value === "string") return value;
+  if (isObjectRecord2(value) && typeof value.id === "string") return value.id;
+  return null;
+}
+function mergeIdentityOrder(base, server, local, retained) {
+  const nodes = [...retained];
+  const outgoing = new Map(nodes.map((id2) => [id2, /* @__PURE__ */ new Set()]));
+  const incoming = new Map(nodes.map((id2) => [id2, 0]));
+  for (const order of [server, local]) {
+    const filtered = order.filter((id2) => retained.has(id2));
+    for (let index = 1; index < filtered.length; index += 1) {
+      const before = filtered[index - 1];
+      const after = filtered[index];
+      const edges = outgoing.get(before);
+      if (edges.has(after)) continue;
+      edges.add(after);
+      incoming.set(after, incoming.get(after) + 1);
+    }
+  }
+  const rank = /* @__PURE__ */ new Map();
+  for (const order of [base, server, local]) {
+    for (const id2 of order) {
+      if (!rank.has(id2)) rank.set(id2, rank.size);
+    }
+  }
+  const ready = nodes.filter((id2) => incoming.get(id2) === 0).sort((left, right) => rank.get(left) - rank.get(right));
+  const result = [];
+  while (ready.length > 0) {
+    const id2 = ready.shift();
+    result.push(id2);
+    for (const after of outgoing.get(id2)) {
+      const count = incoming.get(after) - 1;
+      incoming.set(after, count);
+      if (count === 0) {
+        ready.push(after);
+        ready.sort((left, right) => rank.get(left) - rank.get(right));
+      }
+    }
+  }
+  return result.length === nodes.length ? result : null;
+}
+function selected(value) {
+  return value === void 0 ? { present: false, conflicts: [] } : { present: true, value, conflicts: [] };
+}
+function conflict(path) {
+  return { present: false, conflicts: [path] };
+}
+var init_merge = __esm({
+  "src/project-sync/merge.ts"() {
+    "use strict";
+    init_projection();
+  }
+});
+
+// src/project-manifest/merge.ts
+function isSchemaDocumentRecordKind(recordKind) {
+  return Object.hasOwn(SCHEMA_DOCUMENT_FIELD_CONTRACTS, recordKind);
+}
+function schemaDocumentSemanticallyEqual(recordKind, left, right) {
+  return canonicallyEqual(
+    normalizeDocumentForComparison(recordKind, left, "left"),
+    normalizeDocumentForComparison(recordKind, right, "right")
+  );
+}
+function schemaDocumentAuthoredSemanticallyEqual(recordKind, left, right) {
+  const normalizedLeft = normalizeDocumentForComparison(
+    recordKind,
+    left,
+    "left"
+  );
+  const normalizedRight = normalizeDocumentForComparison(
+    recordKind,
+    right,
+    "right"
+  );
+  return canonicallyEqual(
+    partitionDocumentFields(recordKind, normalizedLeft).authored,
+    partitionDocumentFields(recordKind, normalizedRight).authored
+  );
+}
+function mergeSchemaDocumentRecord(recordKind, base, server, local) {
+  const baseRecord = requireDocumentRecord(base, recordKind, "base");
+  const serverRecord = requireDocumentRecord(server, recordKind, "server");
+  const localRecord = requireDocumentRecord(local, recordKind, "local");
+  const contract = SCHEMA_DOCUMENT_FIELD_CONTRACTS[recordKind];
+  return threeWayMergeRecord(baseRecord, serverRecord, localRecord, {
+    comparison: {
+      base: normalizeDocumentForComparison(recordKind, baseRecord, "base"),
+      server: normalizeDocumentForComparison(
+        recordKind,
+        serverRecord,
+        "server"
+      ),
+      local: normalizeDocumentForComparison(recordKind, localRecord, "local")
+    },
+    serverWinsFields: /* @__PURE__ */ new Set([...contract.derived, ...contract.volatile]),
+    recursive: true
+  });
+}
+function normalizeDocumentForComparison(recordKind, value, side) {
+  const normalized = normalizeDocumentFields(
+    recordKind,
+    requireDocumentRecord(value, recordKind, side)
+  );
+  if (recordKind === "class") {
+    materializeDeclarationOrder(normalized, "schema", "schemaKeyOrder");
+  } else if (recordKind === "interface") {
+    materializeDeclarationOrder(normalized, "members", "memberKeyOrder");
+  } else if (recordKind === "enum") {
+    materializeDeclarationOrder(normalized, "options", "optionKeyOrder");
+  }
+  return normalized;
+}
+function materializeDeclarationOrder(value, recordField, orderField) {
+  const record3 = value[recordField];
+  if (!isObjectRecord2(record3)) return;
+  const explicit = Array.isArray(value[orderField]) ? value[orderField].filter(
+    (entry) => typeof entry === "string" && Object.hasOwn(record3, entry)
+  ) : [];
+  const seen = new Set(explicit);
+  value[orderField] = [
+    ...explicit,
+    ...Object.keys(record3).filter((key) => !seen.has(key))
+  ];
+}
+function requireDocumentRecord(value, recordKind, side) {
+  if (isObjectRecord2(value)) return value;
+  throw new Error(
+    `Schema ${recordKind} ${side} document must be an object for semantic merge.`
+  );
+}
+var init_merge2 = __esm({
+  "src/project-manifest/merge.ts"() {
+    "use strict";
+    init_merge();
+    init_projection();
+    init_contracts();
+  }
+});
+
 // src/project-manifest/adapters.ts
 function createSyntheticDocumentSource(recordKind, recordId, symbolKind) {
   const encodedKind = encodeURIComponent(recordKind);
@@ -28897,7 +29207,13 @@ function composeDocumentRecord(recordKind, recordId, authoredFields, baseRecord)
     }
     assertKnownDocumentFields(recordKind, baseRecord.data);
     const base = partitionDocumentFields(recordKind, baseRecord.data);
-    Object.assign(data, base.derived, base.volatile);
+    const invalidatesDerivedConstructor = recordKind === "constructor" && !schemaDocumentAuthoredSemanticallyEqual(
+      recordKind,
+      baseRecord.data,
+      normalizedAuthored
+    );
+    if (!invalidatesDerivedConstructor) Object.assign(data, base.derived);
+    Object.assign(data, base.volatile);
   }
   if (recordKind === "member" && data.isReadOnly === false && !Object.prototype.hasOwnProperty.call(baseRecord?.data ?? {}, "isReadOnly")) {
     delete data.isReadOnly;
@@ -28921,6 +29237,7 @@ var init_adapters = __esm({
   "src/project-manifest/adapters.ts"() {
     "use strict";
     init_contracts();
+    init_merge2();
     DEFAULT_DOCUMENT_TO_MANIFEST_CONTEXT = {
       sourceForRecord: createSyntheticDocumentSource
     };
@@ -33797,316 +34114,6 @@ var init_document_adapters = __esm({
   }
 });
 
-// src/project-sync/merge.ts
-function threeWayMergeRecord(base, server, local, policy = {}) {
-  const baseRecord = isObjectRecord2(base) ? base : {};
-  const serverRecord = isObjectRecord2(server) ? server : {};
-  const localRecord = isObjectRecord2(local) ? local : {};
-  const comparisonBase = policy.comparison?.base ?? baseRecord;
-  const comparisonServer = policy.comparison?.server ?? serverRecord;
-  const comparisonLocal = policy.comparison?.local ?? localRecord;
-  const merged = {};
-  const conflictFields = [];
-  const keys = /* @__PURE__ */ new Set([
-    ...Object.keys(serverRecord),
-    ...Object.keys(localRecord),
-    ...Object.keys(baseRecord)
-  ]);
-  for (const key of keys) {
-    const rawServerValue = serverRecord[key];
-    const rawLocalValue = localRecord[key];
-    if (policy.serverWinsFields?.has(key) === true) {
-      if (rawServerValue !== void 0) merged[key] = rawServerValue;
-      continue;
-    }
-    const baseValue = comparisonBase[key];
-    const serverValue = comparisonServer[key];
-    const localValue = comparisonLocal[key];
-    const result = mergeValue({
-      rawBase: baseRecord[key],
-      rawServer: rawServerValue,
-      rawLocal: rawLocalValue,
-      base: baseValue,
-      server: serverValue,
-      local: localValue,
-      path: key,
-      recursive: policy.recursive === true
-    });
-    if (result.conflicts.length > 0) {
-      conflictFields.push(...result.conflicts);
-    } else if (result.present) {
-      merged[key] = result.value;
-    }
-  }
-  return { merged, conflictFields };
-}
-function mergeValue(args) {
-  if (canonicallyEqual(args.server, args.base)) {
-    return selected(args.rawLocal);
-  }
-  if (canonicallyEqual(args.local, args.base)) {
-    return selected(args.rawServer);
-  }
-  if (canonicallyEqual(args.local, args.server)) {
-    return selected(args.rawLocal);
-  }
-  if (!args.recursive) return conflict(args.path);
-  if (isObjectRecord2(args.rawBase) && isObjectRecord2(args.rawServer) && isObjectRecord2(args.rawLocal)) {
-    const comparisonBase = isObjectRecord2(args.base) ? args.base : args.rawBase;
-    const comparisonServer = isObjectRecord2(args.server) ? args.server : args.rawServer;
-    const comparisonLocal = isObjectRecord2(args.local) ? args.local : args.rawLocal;
-    const value = {};
-    const conflicts = [];
-    const keys = /* @__PURE__ */ new Set([
-      ...Object.keys(args.rawBase),
-      ...Object.keys(args.rawServer),
-      ...Object.keys(args.rawLocal)
-    ]);
-    for (const key of keys) {
-      const nested = mergeValue({
-        rawBase: args.rawBase[key],
-        rawServer: args.rawServer[key],
-        rawLocal: args.rawLocal[key],
-        base: comparisonBase[key],
-        server: comparisonServer[key],
-        local: comparisonLocal[key],
-        path: `${args.path}.${key}`,
-        recursive: true
-      });
-      conflicts.push(...nested.conflicts);
-      if (nested.present) value[key] = nested.value;
-    }
-    return { present: true, value, conflicts };
-  }
-  if (Array.isArray(args.rawBase) && Array.isArray(args.rawServer) && Array.isArray(args.rawLocal)) {
-    return mergeIdentityArray(
-      args.rawBase,
-      args.rawServer,
-      args.rawLocal,
-      args.path
-    );
-  }
-  return conflict(args.path);
-}
-function mergeIdentityArray(base, server, local, path) {
-  const baseItems = indexIdentityArray(base);
-  const serverItems = indexIdentityArray(server);
-  const localItems = indexIdentityArray(local);
-  if (baseItems === null || serverItems === null || localItems === null) {
-    return conflict(path);
-  }
-  const retained = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  const ids = /* @__PURE__ */ new Set([
-    ...baseItems.order,
-    ...serverItems.order,
-    ...localItems.order
-  ]);
-  for (const id2 of ids) {
-    const baseHas = baseItems.values.has(id2);
-    const serverHas = serverItems.values.has(id2);
-    const localHas = localItems.values.has(id2);
-    const baseValue = baseItems.values.get(id2);
-    const serverValue = serverItems.values.get(id2);
-    const localValue = localItems.values.get(id2);
-    if (baseHas && !serverHas && !localHas) continue;
-    if (baseHas && !serverHas) {
-      if (canonicallyEqual(localValue, baseValue)) continue;
-      conflicts.push(`${path}[${JSON.stringify(id2)}]`);
-      continue;
-    }
-    if (baseHas && !localHas) {
-      if (canonicallyEqual(serverValue, baseValue)) continue;
-      conflicts.push(`${path}[${JSON.stringify(id2)}]`);
-      continue;
-    }
-    if (!serverHas && localHas) {
-      retained.set(id2, localValue);
-      continue;
-    }
-    if (!localHas && serverHas) {
-      retained.set(id2, serverValue);
-      continue;
-    }
-    const merged = mergeValue({
-      rawBase: baseValue,
-      rawServer: serverValue,
-      rawLocal: localValue,
-      base: baseValue,
-      server: serverValue,
-      local: localValue,
-      path: `${path}[${JSON.stringify(id2)}]`,
-      recursive: true
-    });
-    conflicts.push(...merged.conflicts);
-    if (merged.present) retained.set(id2, merged.value);
-  }
-  if (conflicts.length > 0) return { present: true, value: [], conflicts };
-  const order = mergeIdentityOrder(
-    baseItems.order,
-    serverItems.order,
-    localItems.order,
-    new Set(retained.keys())
-  );
-  if (order === null) return conflict(`${path}.$order`);
-  return {
-    present: true,
-    value: order.map((id2) => retained.get(id2)),
-    conflicts: []
-  };
-}
-function indexIdentityArray(values) {
-  const result = /* @__PURE__ */ new Map();
-  const order = [];
-  for (const value of values) {
-    const id2 = identityOf(value);
-    if (id2 === null || result.has(id2)) return null;
-    result.set(id2, value);
-    order.push(id2);
-  }
-  return { order, values: result };
-}
-function identityOf(value) {
-  if (typeof value === "string") return value;
-  if (isObjectRecord2(value) && typeof value.id === "string") return value.id;
-  return null;
-}
-function mergeIdentityOrder(base, server, local, retained) {
-  const nodes = [...retained];
-  const outgoing = new Map(nodes.map((id2) => [id2, /* @__PURE__ */ new Set()]));
-  const incoming = new Map(nodes.map((id2) => [id2, 0]));
-  for (const order of [server, local]) {
-    const filtered = order.filter((id2) => retained.has(id2));
-    for (let index = 1; index < filtered.length; index += 1) {
-      const before = filtered[index - 1];
-      const after = filtered[index];
-      const edges = outgoing.get(before);
-      if (edges.has(after)) continue;
-      edges.add(after);
-      incoming.set(after, incoming.get(after) + 1);
-    }
-  }
-  const rank = /* @__PURE__ */ new Map();
-  for (const order of [base, server, local]) {
-    for (const id2 of order) {
-      if (!rank.has(id2)) rank.set(id2, rank.size);
-    }
-  }
-  const ready = nodes.filter((id2) => incoming.get(id2) === 0).sort((left, right) => rank.get(left) - rank.get(right));
-  const result = [];
-  while (ready.length > 0) {
-    const id2 = ready.shift();
-    result.push(id2);
-    for (const after of outgoing.get(id2)) {
-      const count = incoming.get(after) - 1;
-      incoming.set(after, count);
-      if (count === 0) {
-        ready.push(after);
-        ready.sort((left, right) => rank.get(left) - rank.get(right));
-      }
-    }
-  }
-  return result.length === nodes.length ? result : null;
-}
-function selected(value) {
-  return value === void 0 ? { present: false, conflicts: [] } : { present: true, value, conflicts: [] };
-}
-function conflict(path) {
-  return { present: false, conflicts: [path] };
-}
-var init_merge = __esm({
-  "src/project-sync/merge.ts"() {
-    "use strict";
-    init_projection();
-  }
-});
-
-// src/project-manifest/merge.ts
-function isSchemaDocumentRecordKind(recordKind) {
-  return Object.hasOwn(SCHEMA_DOCUMENT_FIELD_CONTRACTS, recordKind);
-}
-function schemaDocumentSemanticallyEqual(recordKind, left, right) {
-  return canonicallyEqual(
-    normalizeDocumentForComparison(recordKind, left, "left"),
-    normalizeDocumentForComparison(recordKind, right, "right")
-  );
-}
-function schemaDocumentAuthoredSemanticallyEqual(recordKind, left, right) {
-  const normalizedLeft = normalizeDocumentForComparison(
-    recordKind,
-    left,
-    "left"
-  );
-  const normalizedRight = normalizeDocumentForComparison(
-    recordKind,
-    right,
-    "right"
-  );
-  return canonicallyEqual(
-    partitionDocumentFields(recordKind, normalizedLeft).authored,
-    partitionDocumentFields(recordKind, normalizedRight).authored
-  );
-}
-function mergeSchemaDocumentRecord(recordKind, base, server, local) {
-  const baseRecord = requireDocumentRecord(base, recordKind, "base");
-  const serverRecord = requireDocumentRecord(server, recordKind, "server");
-  const localRecord = requireDocumentRecord(local, recordKind, "local");
-  const contract = SCHEMA_DOCUMENT_FIELD_CONTRACTS[recordKind];
-  return threeWayMergeRecord(baseRecord, serverRecord, localRecord, {
-    comparison: {
-      base: normalizeDocumentForComparison(recordKind, baseRecord, "base"),
-      server: normalizeDocumentForComparison(
-        recordKind,
-        serverRecord,
-        "server"
-      ),
-      local: normalizeDocumentForComparison(recordKind, localRecord, "local")
-    },
-    serverWinsFields: /* @__PURE__ */ new Set([...contract.derived, ...contract.volatile]),
-    recursive: true
-  });
-}
-function normalizeDocumentForComparison(recordKind, value, side) {
-  const normalized = normalizeDocumentFields(
-    recordKind,
-    requireDocumentRecord(value, recordKind, side)
-  );
-  if (recordKind === "class") {
-    materializeDeclarationOrder(normalized, "schema", "schemaKeyOrder");
-  } else if (recordKind === "interface") {
-    materializeDeclarationOrder(normalized, "members", "memberKeyOrder");
-  } else if (recordKind === "enum") {
-    materializeDeclarationOrder(normalized, "options", "optionKeyOrder");
-  }
-  return normalized;
-}
-function materializeDeclarationOrder(value, recordField, orderField) {
-  const record3 = value[recordField];
-  if (!isObjectRecord2(record3)) return;
-  const explicit = Array.isArray(value[orderField]) ? value[orderField].filter(
-    (entry) => typeof entry === "string" && Object.hasOwn(record3, entry)
-  ) : [];
-  const seen = new Set(explicit);
-  value[orderField] = [
-    ...explicit,
-    ...Object.keys(record3).filter((key) => !seen.has(key))
-  ];
-}
-function requireDocumentRecord(value, recordKind, side) {
-  if (isObjectRecord2(value)) return value;
-  throw new Error(
-    `Schema ${recordKind} ${side} document must be an object for semantic merge.`
-  );
-}
-var init_merge2 = __esm({
-  "src/project-manifest/merge.ts"() {
-    "use strict";
-    init_merge();
-    init_projection();
-    init_contracts();
-  }
-});
-
 // src/project-manifest/index.ts
 var init_project_manifest = __esm({
   "src/project-manifest/index.ts"() {
@@ -35135,6 +35142,12 @@ function isNSPointerVariable(value) {
   const v = value;
   return v?.type === "variable" /* variable */ && typeof v?.variableId === "string";
 }
+function isNSPointerStaticMember(value) {
+  const v = value;
+  if (v?.type !== "staticMember" /* staticMember */) return false;
+  if (typeof v.memberId !== "string") return false;
+  return v.memberId.length > 0;
+}
 function isNSPointerValue(value) {
   const v = value;
   return v?.type === "value" /* value */ && isNSValue(v?.value);
@@ -35260,7 +35273,7 @@ function isNSPointerFunctionErrorCheck(value) {
   return isNSFunctionErrorCheckMode(v.mode);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -40714,20 +40727,25 @@ function isValidEnumOptionId(id2) {
   if (typeof id2 !== "string" || id2.length === 0) return false;
   return OPTION_ID_REGEX.test(withoutSystemRecordIdPrefix(id2));
 }
+function isProspectiveEnumOptionId(id2) {
+  if (typeof id2 !== "string" || id2.length === 0) return false;
+  if (isPendingId(id2)) return true;
+  return isValidEnumOptionId(id2);
+}
 function isValidEnumOptionName(name) {
   return isValidSchemaAuthoredIdentifier(name);
 }
-function isEnumOption(value) {
+function isEnumOptionWithIds(value, isOptionId) {
   const v = value;
-  return !!v && isValidDocsText(v.docsText) && typeof v.text === "string" && typeof v.id === "string" && isValidEnumOptionId(v.id) && typeof v.name === "string" && isValidEnumOptionName(v.name);
+  return !!v && isValidDocsText(v.docsText) && typeof v.text === "string" && typeof v.id === "string" && isOptionId(v.id) && typeof v.name === "string" && isValidEnumOptionName(v.name);
 }
-function isEnumOptionsRecord(value) {
+function isEnumOptionsRecordWithIds(value, isOptionId) {
   if (value === null || value === void 0) return false;
   if (typeof value !== "object") return false;
   if (Array.isArray(value)) return false;
   for (const [k, v] of Object.entries(value)) {
-    if (!isValidEnumOptionId(k)) return false;
-    if (!isEnumOption(v)) return false;
+    if (!isOptionId(k)) return false;
+    if (!isEnumOptionWithIds(v, isOptionId)) return false;
     if (v.id !== k) return false;
   }
   return true;
@@ -40737,12 +40755,12 @@ function isOptionalOptionKeyOrder(value) {
   if (!Array.isArray(value)) return false;
   return value.every((key) => typeof key === "string");
 }
-function isEnumBase(value) {
+function isEnumBaseWithIds(value, isOptionId) {
   const v = value;
   if (!v) return false;
   if (typeof v.name !== "string") return false;
   if (!isValidDocsText(v.docsText)) return false;
-  if (!isEnumOptionsRecord(v.options)) return false;
+  if (!isEnumOptionsRecordWithIds(v.options, isOptionId)) return false;
   if (!isOptionalOptionKeyOrder(v.optionKeyOrder)) return false;
   if (v.system !== void 0 && v.system !== null) {
     return isSystemMetadata(v.system);
@@ -40767,17 +40785,24 @@ function getEnumOptionKeyOrder(enumDef) {
   }
   return result;
 }
-function isEnumProps(value) {
+function isEnumPropsWithIds(value, isOptionId) {
   const v = value;
-  return isEnumBase(value) && isWithId(value) && typeof v?.projectId === "string" && isEpochMillis(v?.createdAt) && isEpochMillis(v?.updatedAt);
+  return isEnumBaseWithIds(value, isOptionId) && isWithId(value) && typeof v?.projectId === "string" && isEpochMillis(v?.createdAt) && isEpochMillis(v?.updatedAt);
+}
+function isEnumProps(value) {
+  return isEnumPropsWithIds(value, isValidEnumOptionId);
 }
 function isEnum(value) {
   return isEnumProps(value);
 }
+function isProspectiveEnum(value) {
+  return isEnumPropsWithIds(value, isProspectiveEnumOptionId);
+}
 var OPTION_ID_REGEX;
 var init_enum_types = __esm({
   "../src/models/enum/enum-types.ts"() {
     "use strict";
+    init_src();
     init_core();
     init_schema_identifiers();
     init_system_record_id();
@@ -43144,12 +43169,10 @@ ${prefix}${renderType(context, member.returnType)} ${member.name}${body}`;
       (argument2) => `${renderType(context, argument2.type)} ${argument2.name}`
     ).join(", ")})`;
     const tracked = member.kind === "scriptFunction" ? member.script?.sourceText ?? uiFunctionSource(context, member) : null;
-    const body = tracked ? extractBody(tracked) ?? `{
-${indentNeoSourceNonEmptyLines(tracked.trim(), 2)}
-}` : null;
+    const body = tracked === null ? null : emitFunctionBody(tracked);
     const abstractContract = member.modifier === "abstract" || member.modifier === "abstractOverride";
     return `${annotations.join("\n")}
-${body ? `${signature} ${body}` : abstractContract ? `${signature};` : `native ${signature};`}`;
+${body !== null ? `${signature} ${body}` : abstractContract ? `${signature};` : `native ${signature};`}`;
   }
   const type = renderMemberType(context, member, enclosingClassId);
   const initializer = initDefaultSource(member) ?? (member.isStatic ? context.staticInitializers.get(member.id) : void 0) ?? context.defaultInitializers.get(member.id) ?? renderDefault(context, member);
@@ -43951,10 +43974,12 @@ function systemAnnotation2(system) {
   ];
   return `@system(${args.join(", ")})`;
 }
-function extractBody(source) {
-  const start = source.indexOf("{");
-  const end = source.lastIndexOf("}");
-  return start >= 0 && end > start ? source.slice(start, end + 1).trim() : null;
+function emitFunctionBody(sourceText) {
+  const code = sourceText.trim();
+  if (code.length === 0) return "{\n}";
+  return `{
+${indentNeoSourceNonEmptyLines(code, 2)}
+}`;
 }
 function id(value) {
   return `@id(${quote(value)})
@@ -48226,6 +48251,7 @@ function initializerRequiresEvaluation(index, expression, targetClassName, runti
     return true;
   }
   if (expression.kind === "call") return !isLiteralCall(expression);
+  if (isEvaluatedOnlyExpression(expression)) return true;
   if (expression.kind !== "new") return false;
   const className = expression.className ?? targetClassName;
   if (!declaresConstructors(index, className)) return false;
@@ -48301,6 +48327,24 @@ function expressionReadsRuntimeIdentifier(expression, runtimeIdentifiers) {
       return false;
   }
 }
+function isEvaluatedOnlyExpression(expression) {
+  switch (expression.kind) {
+    case "annotated":
+      return isEvaluatedOnlyExpression(expression.expression);
+    case "binary":
+    case "coalesce":
+    case "index":
+    case "is":
+    case "force":
+    case "litInterp":
+      return true;
+    case "unary":
+      if (expression.op !== "-") return true;
+      return isEvaluatedOnlyExpression(expression.operand);
+    default:
+      return false;
+  }
+}
 function isLiteralCall(expression) {
   if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
     return true;
@@ -49232,10 +49276,13 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
     accessModifier: owner.kind === "classMember" ? effectiveSourceAccessModifier(declaration.modifiers, "class") : "public",
     modifier: memberModifier3(declaration.modifiers, base?.modifier),
     locked: hasAnnotation2(declaration.annotations, "locked"),
-    // Every declaration kind carries a type, and its nullability is the whole
-    // of what `required` means. Properties and getters used to fall back to
-    // the pulled value, which left a fresh workspace calling them optional.
-    required: !declaration.type.nullable,
+    // Every value-bearing declaration carries a type, and its nullability is
+    // the whole of what `required` means. Properties and getters used to fall
+    // back to the pulled value, which left a fresh workspace calling them
+    // optional. A callable owns no value, so `required` is fixed `false`
+    // (nsfunction-member.md §1.2, function-member.md) and the declared
+    // nullability travels in `returnTypeInfo.required` instead.
+    required: declaration.kind === "function" ? false : !declaration.type.nullable,
     defaultValue: null,
     overrideOf: inheritedId,
     system: systemMetadata(declaration.annotations),
@@ -49955,15 +50002,7 @@ function lowerDefault(context, initializer, type, ownerClass, base, memberId, st
     return base?.defaultValue && "serverValueId" in base.defaultValue ? base.defaultValue : null;
   }
   const expression = parseExpression(initializer);
-  if (!isStoredDelegateLiteral(type, expression) && initializerRequiresEvaluation(
-    context.declaredConstructors,
-    expression,
-    type.name,
-    requiredConstructorParameterNames(
-      context.declaredConstructors,
-      ownerClass.name
-    )
-  )) {
+  if (positionRequiresEvaluation(context, expression, type, ownerClass)) {
     return { init: { code: normalizeInitializerSource(initializer) } };
   }
   if (context.rowBackedDefaultMemberIds.has(memberId) && base?.defaultValue && !("serverValueId" in base.defaultValue)) {
@@ -50029,15 +50068,7 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
     declaredExpected,
     genericEnvironment
   );
-  if (!isStoredDelegateLiteral(expected, expression) && initializerRequiresEvaluation(
-    context.declaredConstructors,
-    expression,
-    expected.name,
-    requiredConstructorParameterNames(
-      context.declaredConstructors,
-      ownerClass.name
-    )
-  )) {
+  if (positionRequiresEvaluation(context, expression, expected, ownerClass)) {
     return null;
   }
   if (expression.kind === "annotated") {
@@ -50116,10 +50147,20 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       const valueType = expected.arguments[1] ?? expected;
       const value = {};
       for (const entry of expression.entries) {
+        if (positionRequiresEvaluation(
+          context,
+          entry.key,
+          DICTIONARY_KEY_TYPE,
+          ownerClass
+        )) {
+          throw new Error(
+            `Dictionary key at ${path} is a computed expression. Dictionary keys must be string literals.`
+          );
+        }
         const key = lowerExpressionValue(
           context,
           entry.key,
-          { name: "string", nullable: false, arguments: [] },
+          DICTIONARY_KEY_TYPE,
           ownerClass,
           path,
           genericEnvironment,
@@ -50293,6 +50334,18 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       );
   }
 }
+function positionRequiresEvaluation(context, expression, expected, ownerClass) {
+  if (isStoredDelegateLiteral(expected, expression)) return false;
+  return initializerRequiresEvaluation(
+    context.declaredConstructors,
+    expression,
+    expected.name,
+    requiredConstructorParameterNames(
+      context.declaredConstructors,
+      ownerClass.name
+    )
+  );
+}
 function isStoredDelegateLiteral(type, expression) {
   if (type.name !== "NeoDelegate") return false;
   let current = expression;
@@ -50374,10 +50427,20 @@ function lowerStructuredLeafDefault(context, kind, expression, expectedType, own
   });
 }
 function requiredComponentNumber(context, expression, ownerClass, label, path) {
+  if (positionRequiresEvaluation(
+    context,
+    expression,
+    STRUCTURED_LEAF_COMPONENT_TYPE,
+    ownerClass
+  )) {
+    throw new Error(
+      `${label} has a computed component. Structured leaf components must be numeric literals.`
+    );
+  }
   const value = lowerExpressionValue(
     context,
     expression,
-    { name: "float", nullable: false, arguments: [] },
+    STRUCTURED_LEAF_COMPONENT_TYPE,
     ownerClass,
     path
   );
@@ -50965,7 +51028,7 @@ function* zip(left, right) {
     yield [left[index], right[index]];
   }
 }
-var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, primitiveMemberKinds;
+var UNSET_LIST_COLUMN_WIDTH, EMPTY_GENERIC_TYPE_ENVIRONMENT, DICTIONARY_KEY_TYPE, STRUCTURED_LEAF_COMPONENT_TYPE, primitiveMemberKinds;
 var init_lower_members = __esm({
   "src/project-source/lower-members.ts"() {
     "use strict";
@@ -50983,6 +51046,16 @@ var init_lower_members = __esm({
     init_key_reference_spelling();
     UNSET_LIST_COLUMN_WIDTH = -1;
     EMPTY_GENERIC_TYPE_ENVIRONMENT = /* @__PURE__ */ new Map();
+    DICTIONARY_KEY_TYPE = {
+      name: "string",
+      nullable: false,
+      arguments: []
+    };
+    STRUCTURED_LEAF_COMPONENT_TYPE = {
+      name: "float",
+      nullable: false,
+      arguments: []
+    };
     primitiveMemberKinds = /* @__PURE__ */ new Set([
       "null",
       "bool",
@@ -55230,6 +55303,16 @@ function liveListIndexRegistry(ctx) {
   liveListIndexesByProject.set(projectKey, created);
   return created;
 }
+function evaluatorOwnershipCachesForBase(base) {
+  const existing = evaluatorOwnershipCachesByBase.get(base);
+  if (existing !== void 0) return existing;
+  const created = {
+    ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
+    ownershipDistancesByRowId: /* @__PURE__ */ new Map()
+  };
+  evaluatorOwnershipCachesByBase.set(base, created);
+  return created;
+}
 function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
   values.map((row) => [row.id, row])
 )) {
@@ -55239,9 +55322,15 @@ function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
     parentLinksByChildId: /* @__PURE__ */ new Map(),
     indexedRowIds: /* @__PURE__ */ new Set(),
     indexedOverlayValues: /* @__PURE__ */ new Map(),
+    indexedOverlayRowCount: 0,
     shadowedBaseRowIds: /* @__PURE__ */ new Set(),
     listIdentityByArray: /* @__PURE__ */ new WeakMap(),
-    declaredListByArray: /* @__PURE__ */ new WeakMap()
+    declaredListByArray: /* @__PURE__ */ new WeakMap(),
+    rowsBySourceValueId: /* @__PURE__ */ new Map(),
+    ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
+    ownershipDistancesByRowId: /* @__PURE__ */ new Map(),
+    ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
+    memberByRowId: /* @__PURE__ */ new Map()
   };
   const membersByValueId = /* @__PURE__ */ new Map();
   for (const member of members) {
@@ -55260,7 +55349,8 @@ function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
     memberByValueId: indexes.memberByValueId,
     membersByValueId,
     parentLinksByChildId: indexes.parentLinksByChildId,
-    indexedRowIds: indexes.indexedRowIds
+    indexedRowIds: indexes.indexedRowIds,
+    rowsBySourceValueId: indexes.rowsBySourceValueId
   };
 }
 function evaluatorIndexes(ctx) {
@@ -55271,6 +55361,8 @@ function evaluatorIndexes(ctx) {
   }
   const liveListIndexes = liveListIndexRegistry(ctx);
   const base = ctx.vm.databaseVM?.evaluatorIndexes;
+  const hasLocalRows = ctx.__runtimeSessionValues !== void 0 || ctx.__valueOverlay !== void 0;
+  const sharedOwnershipCaches = base !== void 0 && !hasLocalRows ? evaluatorOwnershipCachesForBase(base) : null;
   const indexes = {
     rowByValueReference: /* @__PURE__ */ new WeakMap(),
     baseRowByValueReference: base?.rowByValueReference,
@@ -55280,10 +55372,20 @@ function evaluatorIndexes(ctx) {
     indexedRowIds: /* @__PURE__ */ new Set(),
     baseIndexedRowIds: base?.indexedRowIds,
     indexedOverlayValues: /* @__PURE__ */ new Map(),
+    indexedOverlayRowCount: 0,
     shadowedBaseRowIds: /* @__PURE__ */ new Set(),
     overlayRevision,
     listIdentityByArray: liveListIndexes?.identity ?? /* @__PURE__ */ new WeakMap(),
-    declaredListByArray: liveListIndexes?.declared ?? /* @__PURE__ */ new WeakMap()
+    declaredListByArray: liveListIndexes?.declared ?? /* @__PURE__ */ new WeakMap(),
+    rowsBySourceValueId: /* @__PURE__ */ new Map(),
+    baseRowsBySourceValueId: base?.rowsBySourceValueId,
+    // A base index describes one immutable evaluator document. Getter calls
+    // over that document can safely share the expensive ownership walks. A
+    // runtime/overlay context gets private caches because it shadows edges.
+    ownershipRootIdsByRowId: sharedOwnershipCaches?.ownershipRootIdsByRowId ?? /* @__PURE__ */ new Map(),
+    ownershipDistancesByRowId: sharedOwnershipCaches?.ownershipDistancesByRowId ?? /* @__PURE__ */ new Map(),
+    ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
+    memberByRowId: /* @__PURE__ */ new Map()
   };
   if (base === void 0) {
     for (const member of ctx.vm.members) {
@@ -55308,19 +55410,47 @@ function evaluatorIndexes(ctx) {
 }
 function syncLazyOverlayReferences(indexes, overlay) {
   if (!(overlay instanceof LazyValueOverlay)) return;
-  for (const row of overlay.values()) {
-    if (indexes.indexedOverlayValues.get(row.id) === row.value) continue;
+  const materializedRows = overlay.materializedRowsSince(
+    indexes.indexedOverlayRowCount
+  );
+  for (const row of materializedRows) {
     indexes.indexedOverlayValues.set(row.id, row.value);
     if (typeof row.value === "object" && row.value !== null) {
       indexes.rowByValueReference.set(row.value, row);
     }
   }
+  indexes.indexedOverlayRowCount += materializedRows.length;
 }
 function indexEvaluatorRow(indexes, row, allowBaseShadow = false) {
+  indexes.ownedValueAttachmentsByValueId.delete(row.id);
+  if (Array.isArray(row.value)) {
+    for (const childId of row.value) {
+      if (typeof childId === "string") {
+        indexes.ownedValueAttachmentsByValueId.delete(childId);
+      }
+    }
+  } else if (typeof row.value === "object" && row.value !== null) {
+    for (const childId of Object.values(row.value)) {
+      if (typeof childId === "string") {
+        indexes.ownedValueAttachmentsByValueId.delete(childId);
+      }
+    }
+  }
+  indexes.ownershipRootIdsByRowId.clear();
+  indexes.ownershipDistancesByRowId.clear();
+  indexes.memberByRowId.clear();
   if (indexes.indexedRowIds.has(row.id) || !allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true) {
     return;
   }
   indexes.indexedRowIds.add(row.id);
+  if (typeof row.sourceValueId === "string") {
+    const rows = indexes.rowsBySourceValueId.get(row.sourceValueId) ?? [];
+    rows.push(row);
+    indexes.rowsBySourceValueId.set(row.sourceValueId, rows);
+  }
+  if (typeof row.containerId === "string") {
+    addEvaluatorParentLink(indexes, row.id, row.containerId, "");
+  }
   if (typeof row.value === "object" && row.value !== null) {
     indexes.rowByValueReference.set(row.value, row);
   }
@@ -55354,6 +55484,102 @@ function evaluatorParentLinks(indexes, childId) {
   if (local.length === 0) return base;
   return [...base, ...local];
 }
+function evaluatorRowsForSourceValueId(indexes, sourceValueId) {
+  const base = (indexes.baseRowsBySourceValueId?.get(sourceValueId) ?? []).filter((row) => !indexes.shadowedBaseRowIds.has(row.id));
+  const local = indexes.rowsBySourceValueId.get(sourceValueId) ?? [];
+  if (base.length === 0) return local;
+  if (local.length === 0) return base;
+  return [...base, ...local];
+}
+function evaluatorOwnershipRootIds(rowId, indexes) {
+  const cached = indexes.ownershipRootIdsByRowId.get(rowId);
+  if (cached !== void 0) return cached;
+  const roots = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (currentId) => {
+    if (visiting.has(currentId)) return;
+    visiting.add(currentId);
+    const parents = evaluatorParentLinks(indexes, currentId);
+    if (parents.length === 0) roots.add(currentId);
+    else for (const parent of parents) visit(parent.parentId);
+    visiting.delete(currentId);
+  };
+  visit(rowId);
+  if (roots.size === 0) roots.add(rowId);
+  indexes.ownershipRootIdsByRowId.set(rowId, roots);
+  return roots;
+}
+function evaluatorOwnershipDistances(rowId, indexes) {
+  const cached = indexes.ownershipDistancesByRowId.get(rowId);
+  if (cached !== void 0) return cached;
+  const distances = /* @__PURE__ */ new Map([[rowId, 0]]);
+  const pending = [rowId];
+  while (pending.length > 0) {
+    const currentId = pending.shift();
+    if (currentId === void 0) break;
+    const currentDistance = distances.get(currentId);
+    if (currentDistance === void 0) continue;
+    for (const parent of evaluatorParentLinks(indexes, currentId)) {
+      const nextDistance = currentDistance + 1;
+      const previousDistance = distances.get(parent.parentId);
+      if (previousDistance !== void 0 && previousDistance <= nextDistance) {
+        continue;
+      }
+      distances.set(parent.parentId, nextDistance);
+      pending.push(parent.parentId);
+    }
+  }
+  indexes.ownershipDistancesByRowId.set(rowId, distances);
+  return distances;
+}
+function resolveRuntimeReferenceRow(sourceValueId, ctx) {
+  const direct = evalValueById(
+    ctx.vm,
+    sourceValueId,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  const receiver = trackedRowForValueReference(ctx.thisValue, ctx);
+  if (receiver === null) return direct;
+  const indexes = evaluatorIndexes(ctx);
+  const receiverRoots = evaluatorOwnershipRootIds(receiver.id, indexes);
+  const matches = evaluatorRowsForSourceValueId(indexes, sourceValueId).filter(
+    (candidate) => {
+      const candidateRoots = evaluatorOwnershipRootIds(candidate.id, indexes);
+      for (const rootId of candidateRoots) {
+        if (receiverRoots.has(rootId)) return true;
+      }
+      return false;
+    }
+  );
+  if (matches.length === 0) return direct;
+  if (matches.length === 1) return matches[0] ?? direct;
+  const receiverDistances = evaluatorOwnershipDistances(receiver.id, indexes);
+  let nearestDistance = Number.POSITIVE_INFINITY;
+  let nearestMatches = [];
+  for (const candidate of matches) {
+    const candidateDistances = evaluatorOwnershipDistances(
+      candidate.id,
+      indexes
+    );
+    let distance = Number.POSITIVE_INFINITY;
+    for (const [ownerId, receiverDistance] of receiverDistances) {
+      const candidateDistance = candidateDistances.get(ownerId);
+      if (candidateDistance === void 0) continue;
+      distance = Math.min(distance, receiverDistance + candidateDistance);
+    }
+    if (distance < nearestDistance) {
+      nearestDistance = distance;
+      nearestMatches = [candidate];
+    } else if (distance === nearestDistance) {
+      nearestMatches.push(candidate);
+    }
+  }
+  if (nearestMatches.length === 1) return nearestMatches[0] ?? direct;
+  throw new NSGetterRuntimeError(
+    `Value reference '${sourceValueId}' is ambiguous within the constructed object graph.`
+  );
+}
 function invalidateEvaluatorIndexes(ctx) {
   if (ctx.__valueOverlay instanceof LazyValueOverlay) {
     ctx.__valueOverlay.markMutated();
@@ -55564,6 +55790,8 @@ function withEvaluationRuntime(ctx, writes) {
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
       loopIterations: 0,
+      budgetedConstructedRowIds: /* @__PURE__ */ new Set(),
+      budgetedProducedEntriesByRowId: /* @__PURE__ */ new Map(),
       budget: createExecutionBudget(ctx.executionBudgetLimits)
     },
     __indexes: ctx.__executionState === void 0 || ctx.__valueOverlay === void 0 ? void 0 : ctx.__indexes
@@ -57211,12 +57439,7 @@ function evalPointer(pointer, scope, ctx) {
       return scope.get(pointer.variableId);
     }
     case "reference" /* reference */: {
-      const row = evalValueById(
-        ctx.vm,
-        pointer.valueId,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
+      const row = resolveRuntimeReferenceRow(pointer.valueId, ctx);
       if (!row) {
         throw new NSGetterRuntimeError(
           `Missing value reference: ${pointer.valueId}`
@@ -58432,7 +58655,16 @@ function resolveLocalizedRowValueForMember(row, member, ctx) {
   if (member.localizable === false) return value;
   return resolveLocalizedTextId(value, ctx);
 }
-function memberForValueRow(row, ctx, visited = /* @__PURE__ */ new Set()) {
+function memberForValueRow(row, ctx) {
+  const indexes = evaluatorIndexes(ctx);
+  if (indexes.memberByRowId.has(row.id)) {
+    return indexes.memberByRowId.get(row.id) ?? null;
+  }
+  const member = resolveMemberForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  indexes.memberByRowId.set(row.id, member);
+  return member;
+}
+function resolveMemberForValueRow(row, ctx, visited) {
   if (visited.has(row.id)) return null;
   visited.add(row.id);
   const indexes = evaluatorIndexes(ctx);
@@ -58452,7 +58684,11 @@ function memberForValueRow(row, ctx, visited = /* @__PURE__ */ new Set()) {
       ctx.__valueOverlay
     );
     if (parent === null) continue;
-    const parentMember = memberForValueRow(parent, ctx, new Set(visited));
+    const parentMember = resolveMemberForValueRow(
+      parent,
+      ctx,
+      new Set(visited)
+    );
     if (parentMember !== null && isMemberList(parentMember)) {
       return evalMemberById(ctx.vm, parentMember.entryMemberId);
     }
@@ -59482,23 +59718,29 @@ function publishConstructedRows(args) {
       "Class construction requires an effect-capable evaluator Session scope."
     );
   }
+  let newlyConstructedRows = 0;
+  let newlyProducedEntries = 0;
+  for (const row of createdValues) {
+    if (!state.budgetedConstructedRowIds.has(row.id)) {
+      state.budgetedConstructedRowIds.add(row.id);
+      newlyConstructedRows += 1;
+    }
+    const currentEntries = Array.isArray(row.value) ? row.value.length : typeof row.value === "object" && row.value !== null ? Object.keys(row.value).length : 0;
+    const priorEntries = state.budgetedProducedEntriesByRowId.get(row.id) ?? 0;
+    if (currentEntries <= priorEntries) continue;
+    newlyProducedEntries += currentEntries - priorEntries;
+    state.budgetedProducedEntriesByRowId.set(row.id, currentEntries);
+  }
   consumeBudget(
     ctx,
     "constructedSessionRows",
-    createdValues.length,
+    newlyConstructedRows,
     "constructed Session row"
   );
-  let producedEntries = 0;
-  for (const row of createdValues) {
-    if (Array.isArray(row.value)) producedEntries += row.value.length;
-    else if (typeof row.value === "object" && row.value !== null) {
-      producedEntries += Object.keys(row.value).length;
-    }
-  }
   consumeBudget(
     ctx,
     "producedCollectionEntries",
-    producedEntries,
+    newlyProducedEntries,
     "produced collection entry"
   );
   const retained = retainedIds;
@@ -60186,15 +60428,16 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   }
   if (rootRow === null) {
     const existingValueRow = trackedRowForValueReference(result.value, ctx);
+    const existingRuntimeClassId = existingValueRow === null ? null : classIdForValueRow(existingValueRow, ctx) ?? null;
     const existingConstructorRootId = existingValueRow === null ? null : constructorGroupForRow(existingValueRow.id, ctx);
     if (existingValueRow !== null && existingConstructorRootId === existingValueRow.id) {
       return {
         value: result.value,
-        classId: existingValueRow.classId ?? null,
+        classId: existingRuntimeClassId,
         existingValueRow
       };
     }
-    return { value: result.value, classId: null };
+    return { value: result.value, classId: existingRuntimeClassId };
   }
   ctx.__runtimeSessionValues?.delete(rootRow.id);
   ctx.__executionState?.constructorGroups.delete(rootRow.id);
@@ -60537,6 +60780,9 @@ function assertOwnedValueAttachable(valueId, destination, destinationName2, ctx,
   }
 }
 function currentOwnedValueAttachments(valueId, ctx) {
+  const indexes = evaluatorIndexes(ctx);
+  const cached = indexes.ownedValueAttachmentsByValueId.get(valueId);
+  if (cached !== void 0) return [...cached];
   const found = /* @__PURE__ */ new Map();
   const add = (attachment) => {
     found.set(attachment.identity, attachment);
@@ -60575,9 +60821,7 @@ function currentOwnedValueAttachments(valueId, ctx) {
     }
   }
   const parentIds = new Set(
-    evaluatorParentLinks(evaluatorIndexes(ctx), valueId).map(
-      (link) => link.parentId
-    )
+    evaluatorParentLinks(indexes, valueId).map((link) => link.parentId)
   );
   for (const parentId of parentIds) {
     const parent = evalValueById(
@@ -60588,21 +60832,25 @@ function currentOwnedValueAttachments(valueId, ctx) {
     );
     if (parent === null) continue;
     if (parent.id === valueId) continue;
-    let member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
-    if (member !== null) {
-      try {
-        member = resolveMember2(member, ctx.vm.members);
-        if (parent.genericBindings !== void 0) {
-          member = substituteMember(
-            member,
-            envFromStamp(parent.genericBindings),
-            ctx.vm.members
-          );
+    let member = null;
+    let classId = parent.classId;
+    if (classId === void 0) {
+      member = activeStaticBindingRoot(parent.id, ctx)?.member ?? memberForValueRow(parent, ctx);
+      if (member !== null) {
+        try {
+          member = resolveMember2(member, ctx.vm.members);
+          if (parent.genericBindings !== void 0) {
+            member = substituteMember(
+              member,
+              envFromStamp(parent.genericBindings),
+              ctx.vm.members
+            );
+          }
+        } catch {
         }
-      } catch {
       }
+      classId = member !== null && isMemberClassBase(member) ? member.classId : void 0;
     }
-    const classId = parent.classId ?? (member !== null && isMemberClassBase(member) ? member.classId : void 0);
     if (classId !== void 0 && typeof parent.value === "object" && parent.value !== null && !Array.isArray(parent.value)) {
       for (const [key, childId] of Object.entries(parent.value)) {
         if (childId !== valueId) continue;
@@ -60633,7 +60881,9 @@ function currentOwnedValueAttachments(valueId, ctx) {
       }
     }
   }
-  return [...found.values()];
+  const attachments = [...found.values()];
+  indexes.ownedValueAttachmentsByValueId.set(valueId, attachments);
+  return attachments;
 }
 function constructorArgumentStorage(valueId, ctx, visiting = /* @__PURE__ */ new Set()) {
   if (ctx.__runtimeSessionValues?.has(valueId)) return "session" /* Session */;
@@ -61143,13 +61393,15 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
       `Class.Clone source value '${sourceId3}' could not be read.`
     );
   }
-  const runtimeClassId = classIdForValueRow(source, ctx);
-  if (runtimeClassId === void 0) {
+  const resolvedRuntimeClassId = classIdForValueRow(source, ctx);
+  const runtimeClassId = resolvedRuntimeClassId ?? expectedClassId;
+  if (runtimeClassId !== expectedClassId && !resolveInheritanceChain(runtimeClassId, ctx.vm.classes).some(
+    (candidate) => candidate.id === expectedClassId
+  )) {
     throw new NSGetterRuntimeError(
-      `Class.Clone source value '${sourceId3}' has no Class runtime type.`
+      `Class.Clone source value '${sourceId3}' has runtime Class '${runtimeClassId}', which is not assignable to '${expectedClassId}'.`
     );
   }
-  void expectedClassId;
   const destination = ctx.__runtimeSessionValues ?? (() => {
     throw new NSGetterRuntimeError(
       "Class.Clone requires an evaluator Session value registry."
@@ -61272,7 +61524,10 @@ function cloneClassValueGraph(receiver, expectedClassId, ctx) {
     return clone;
   };
   const rootMember = memberForValueRow(source, ctx);
-  return cloneRow(source, rootMember).value;
+  const typedSource = source.classId === void 0 ? { ...source, classId: runtimeClassId } : source;
+  const clonedRoot = cloneRow(typedSource, rootMember);
+  clonedRoot.classId ??= runtimeClassId;
+  return clonedRoot.value;
 }
 function ownedObjectChildMember(row, sourceMember, key, ctx) {
   if (sourceMember !== null && isMemberDictionary(sourceMember)) {
@@ -61451,7 +61706,7 @@ function pushParams(parent, parameters, positional, isList) {
   }
   return child;
 }
-var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
+var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
 var init_evaluateNSGetter = __esm({
   "../src/view-models/neoscript-evaluator/evaluateNSGetter.ts"() {
     "use strict";
@@ -61486,10 +61741,11 @@ var init_evaluateNSGetter = __esm({
       workUnits: 1e5,
       collectionVisits: 1e5,
       producedCollectionEntries: 1e4,
-      constructedSessionRows: 1e3,
+      constructedSessionRows: 4096,
       producedStringCharacters: 1024 * 1024
     });
     liveListIndexesByProject = /* @__PURE__ */ new WeakMap();
+    evaluatorOwnershipCachesByBase = /* @__PURE__ */ new WeakMap();
     MAX_CONSTRUCTION_DEPTH = 64;
     MAX_LOOP_ITERATIONS = 1e4;
     LazyValueOverlay = class extends Map {
@@ -61499,6 +61755,7 @@ var init_evaluateNSGetter = __esm({
       }
       vm;
       revision = 0;
+      materializedRows = [];
       sourceIndexes;
       sourceValueByClone = /* @__PURE__ */ new WeakMap();
       get(id2) {
@@ -61514,8 +61771,12 @@ var init_evaluateNSGetter = __esm({
           this.sourceValueByClone.set(value, source.value);
         }
         super.set(id2, clone);
+        this.materializedRows.push(clone);
         return clone;
       }
+      materializedRowsSince(index) {
+        return this.materializedRows.slice(index);
+      }
       cloneForValueReference(value) {
         const source = this.ensureSourceIndexes().byReference.get(value);
         return source === void 0 ? void 0 : this.get(source.id)?.value;
@@ -63210,7 +63471,11 @@ function readProjectDocument(value, options = {}) {
       isInternalRecordRelation
     ),
     values: readArrayField(value, "values", isMemberValue),
-    enums: readArrayField(value, "enums", isEnum),
+    enums: readArrayField(
+      value,
+      "enums",
+      options.identities === "prospective" ? isProspectiveEnum : isEnum
+    ),
     interfaces: readArrayField(value, "interfaces", isNeoInterface),
     dialogues: readArrayField(value, "dialogues", isDialogue),
     dialogueRecords: readOptionalArrayField(
@@ -72211,6 +72476,145 @@ var init_trusted_commit_verification = __esm({
 });
 
 // ../src/models/classes/world-layer-link-target.ts
+function validateWorldLayerLinkClassTargets(args) {
+  for (const schemaClass2 of args.classes) {
+    if (args.classIds !== void 0 && !args.classIds.has(schemaClass2.id)) {
+      continue;
+    }
+    const directWorldKind = schemaClass2.system?.worldKind;
+    const isSystemLinkBase = directWorldKind === NeoWorldSystemClassKind.TileLayerLink || directWorldKind === NeoWorldSystemClassKind.ObjectLayerLink;
+    const descriptor = worldLayerLinkTargetDescriptorForClass(
+      schemaClass2.id,
+      args.classes
+    );
+    if (descriptor === null) continue;
+    if (isSystemLinkBase) {
+      if (!schemaClass2.isAbstract) {
+        throw new Error(
+          `System layer-link base class "${schemaClass2.id}" must remain abstract.`
+        );
+      }
+      if (worldLayerLinkTargetRelations(
+        schemaClass2.id,
+        descriptor,
+        args.relations
+      ).length > 0) {
+        throw new Error(
+          `System layer-link base class "${schemaClass2.id}" cannot declare a layer target relation.`
+        );
+      }
+      continue;
+    }
+    if (schemaClass2.isAbstract) continue;
+    resolveWorldLayerLinkTarget({
+      classes: args.classes,
+      linkLabel: `Concrete layer-link class "${schemaClass2.id}"`,
+      relations: args.relations,
+      sourceClassId: schemaClass2.id
+    });
+  }
+}
+function worldLayerLinkTargetDescriptorForClass(classId, classes) {
+  const worldKind = resolveWorldSystemClassKind(classId, classes);
+  if (worldKind === NeoWorldSystemClassKind.TileLayerLink) {
+    return {
+      relationKind: InternalRecordRelationKind.WorldTileLayerLinkTarget,
+      targetWorldKind: NeoWorldSystemClassKind.TileLayer
+    };
+  }
+  if (worldKind === NeoWorldSystemClassKind.ObjectLayerLink) {
+    return {
+      relationKind: InternalRecordRelationKind.WorldObjectLayerLinkTarget,
+      targetWorldKind: NeoWorldSystemClassKind.ObjectLayer
+    };
+  }
+  return null;
+}
+function worldLayerLinkTargetRelations(classId, descriptor, relations) {
+  return relations.filter(
+    (relation) => relation.relationKind === descriptor.relationKind && relation.sourceRecordKind === ProjectRecordKind.Class && relation.sourceRecordId === classId && relation.targetRecordKind === ProjectRecordKind.Class
+  );
+}
+function resolveWorldLayerLinkTarget(args) {
+  const label = args.linkLabel ?? `Layer-link class "${args.sourceClassId}"`;
+  const sourceClass = args.classes.find(
+    (candidate) => candidate.id === args.sourceClassId
+  );
+  if (sourceClass === void 0) {
+    throw new Error(
+      `${label} references missing class "${args.sourceClassId}".`
+    );
+  }
+  if (sourceClass.isAbstract) {
+    throw new Error(
+      `${label} cannot instantiate abstract class "${args.sourceClassId}".`
+    );
+  }
+  const descriptor = worldLayerLinkTargetDescriptorForClass(
+    args.sourceClassId,
+    args.classes
+  );
+  if (descriptor === null) {
+    throw new Error(
+      `${label} class "${args.sourceClassId}" is not a tile/object layer-link class.`
+    );
+  }
+  const effective = resolveEffectiveClassRelations({
+    relationKind: descriptor.relationKind,
+    sourceClassId: args.sourceClassId,
+    relations: args.relations,
+    classes: args.classes
+  });
+  if (effective.length > 1) {
+    throw new Error(
+      `${label} class "${args.sourceClassId}" resolves more than one effective target for relation kind "${descriptor.relationKind}".`
+    );
+  }
+  const relationTarget = effective[0] ?? null;
+  if (relationTarget !== null) {
+    const declarationClass = args.classes.find(
+      (candidate) => candidate.id === relationTarget.declaredSourceRecordId
+    );
+    if (declarationClass?.system?.worldKind === NeoWorldSystemClassKind.TileLayerLink || declarationClass?.system?.worldKind === NeoWorldSystemClassKind.ObjectLayerLink) {
+      throw new Error(
+        `${label} class "${args.sourceClassId}" cannot inherit a layer target relation from system base class "${declarationClass.id}".`
+      );
+    }
+  }
+  if (relationTarget === null) {
+    throw new Error(
+      `${label} class "${args.sourceClassId}" has no effective layer target relation.`
+    );
+  }
+  const targetClassId = relationTarget.targetRecordId;
+  const targetClass = args.classes.find(
+    (candidate) => candidate.id === targetClassId
+  );
+  if (targetClass === void 0) {
+    throw new Error(`${label} targets missing layer class "${targetClassId}".`);
+  }
+  if (targetClass.isAbstract) {
+    throw new Error(
+      `${label} targets abstract layer class "${targetClassId}".`
+    );
+  }
+  const targetWorldKind = resolveWorldSystemClassKind(
+    targetClass.id,
+    args.classes
+  );
+  if (targetWorldKind !== descriptor.targetWorldKind) {
+    throw new Error(
+      `${label} targets class "${targetClassId}" of world kind "${String(targetWorldKind)}"; expected "${descriptor.targetWorldKind}".`
+    );
+  }
+  return {
+    declaredSourceClassId: relationTarget.declaredSourceRecordId,
+    relationIds: relationTarget.relationIds,
+    relationKind: descriptor.relationKind,
+    sourceClassId: args.sourceClassId,
+    targetClassId
+  };
+}
 var init_world_layer_link_target = __esm({
   "../src/models/classes/world-layer-link-target.ts"() {
     "use strict";
@@ -72221,6 +72625,292 @@ var init_world_layer_link_target = __esm({
 });
 
 // ../src/models/project/world-content-sidecar-validation.ts
+function validateWorldContentSidecars(args) {
+  const valuesById = new Map(args.values.map((value) => [value.id, value]));
+  const classesById = new Map(
+    args.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const containedIds = containedValueIdsByContainer(args.values);
+  const ownedLinkIds = /* @__PURE__ */ new Map();
+  const gridOwnedLinkIds = /* @__PURE__ */ new Set();
+  const validatedPlacementIds = /* @__PURE__ */ new Set();
+  const reachablePlacementIds = /* @__PURE__ */ new Set();
+  for (const gridValue of args.values) {
+    if (worldKindForValue(gridValue, args.classes) !== NeoWorldSystemClassKind.TileGrid) {
+      continue;
+    }
+    const gridClassId = requiredValueClassId(gridValue, "tile-grid");
+    const gridRecord = valueObjectRecord(gridValue);
+    if (gridRecord === null) continue;
+    const childrenList = referencedValue(
+      gridRecord.Children,
+      valuesById,
+      `Grid value "${gridValue.id}" Children`
+    );
+    if (childrenList === null) continue;
+    const registeredTileLayers = effectiveTargetIds({
+      classes: args.classes,
+      relationKind: InternalRecordRelationKind.WorldGridTileLayer,
+      relations: args.relations,
+      sourceClassId: gridClassId
+    });
+    const registeredObjectLayers = effectiveTargetIds({
+      classes: args.classes,
+      relationKind: InternalRecordRelationKind.WorldGridObjectLayer,
+      relations: args.relations,
+      sourceClassId: gridClassId
+    });
+    const importedTiles = effectiveTargetIds({
+      classes: args.classes,
+      relationKind: InternalRecordRelationKind.WorldGridTileImport,
+      relations: args.relations,
+      sourceClassId: gridClassId
+    });
+    const importedObjects = effectiveTargetIds({
+      classes: args.classes,
+      relationKind: InternalRecordRelationKind.WorldGridObjectImport,
+      relations: args.relations,
+      sourceClassId: gridClassId
+    });
+    const overrideOwnerByLayerKey = /* @__PURE__ */ new Map();
+    for (const linkId of containmentEntryIds(childrenList, containedIds)) {
+      const linkValue = valuesById.get(linkId);
+      if (linkValue === void 0) {
+        throw new Error(
+          `Grid value "${gridValue.id}" Children references missing value "${linkId}".`
+        );
+      }
+      const linkKind = worldKindForValue(linkValue, args.classes);
+      if (linkKind !== NeoWorldSystemClassKind.TileLayerLink && linkKind !== NeoWorldSystemClassKind.ObjectLayerLink) {
+        continue;
+      }
+      const linkRecord = valueObjectRecord(linkValue);
+      if (linkRecord === null) continue;
+      gridOwnedLinkIds.add(linkValue.id);
+      const placementListKey = linkKind === NeoWorldSystemClassKind.TileLayerLink ? "Tiles" : "Objects";
+      const placementList = referencedValue(
+        linkRecord[placementListKey],
+        valuesById,
+        `Layer link value "${linkValue.id}" ${placementListKey}`
+      );
+      const placementIds = placementList === null ? [] : containmentEntryIds(placementList, containedIds);
+      for (const placementId of placementIds) {
+        reachablePlacementIds.add(placementId);
+      }
+      const linkClassId = requiredValueClassId(linkValue, "layer-link");
+      const layerClassId = resolveWorldLayerLinkTarget({
+        classes: args.classes,
+        linkLabel: `Layer link value "${linkValue.id}"`,
+        relations: args.relations,
+        sourceClassId: linkClassId
+      }).targetClassId;
+      const existingOwner = ownedLinkIds.get(linkValue.id);
+      if (existingOwner !== void 0 && existingOwner !== gridValue.id) {
+        throw new Error(
+          `Layer link value "${linkValue.id}" is owned by both grid values "${existingOwner}" and "${gridValue.id}".`
+        );
+      }
+      ownedLinkIds.set(linkValue.id, gridValue.id);
+      const isTile = linkKind === NeoWorldSystemClassKind.TileLayerLink;
+      const expectedLayerKind = isTile ? NeoWorldSystemClassKind.TileLayer : NeoWorldSystemClassKind.ObjectLayer;
+      assertConcreteWorldClass({
+        classId: layerClassId,
+        classes: args.classes,
+        classesById,
+        expectedKind: expectedLayerKind,
+        label: `Layer link value "${linkValue.id}" target`
+      });
+      const registeredLayers = isTile ? registeredTileLayers : registeredObjectLayers;
+      if (!registeredLayers.has(layerClassId)) {
+        throw new Error(
+          `Layer link value "${linkValue.id}" binds unregistered ${isTile ? "tile" : "object"} layer class "${layerClassId}" on grid value "${gridValue.id}".`
+        );
+      }
+      const layerOverrideValueId = optionalNonEmptyString(
+        linkRecord.layerOverrideValueId
+      );
+      const layerKey = `${isTile ? "tile" : "object"}:${layerClassId}`;
+      if (layerOverrideValueId !== null) {
+        const existingOverrideOwner = overrideOwnerByLayerKey.get(layerKey);
+        if (existingOverrideOwner !== void 0 && existingOverrideOwner !== linkValue.id) {
+          throw new Error(
+            `Grid value "${gridValue.id}" has more than one override-owning ${isTile ? "tile" : "object"} layer link for class "${layerClassId}" ("${existingOverrideOwner}" and "${linkValue.id}"). Source links may share a layer target, but at most one may define layerOverrideValueId.`
+          );
+        }
+        overrideOwnerByLayerKey.set(layerKey, linkValue.id);
+      }
+      validateOwnedSparseValue({
+        classesById,
+        expectedClassId: layerClassId,
+        ownerId: linkValue.id,
+        referenceId: layerOverrideValueId,
+        referenceLabel: `Layer link value "${linkValue.id}" layerOverrideValueId`,
+        valuesById
+      });
+      for (const placementId of placementIds) {
+        const placement = valuesById.get(placementId);
+        if (placement === void 0) {
+          throw new Error(
+            `Layer link value "${linkValue.id}" ${placementListKey} references missing placement "${placementId}".`
+          );
+        }
+        validateWorldPlacementSidecars({
+          classes: args.classes,
+          classesById,
+          importedClassIds: isTile ? importedTiles : importedObjects,
+          isTile,
+          layerClassId,
+          linkValueId: linkValue.id,
+          placement,
+          relations: args.relations,
+          valuesById
+        });
+        validatedPlacementIds.add(placement.id);
+      }
+    }
+  }
+  for (const linkValue of args.values) {
+    if (gridOwnedLinkIds.has(linkValue.id)) continue;
+    const linkKind = worldKindForValue(linkValue, args.classes);
+    if (linkKind !== NeoWorldSystemClassKind.TileLayerLink && linkKind !== NeoWorldSystemClassKind.ObjectLayerLink) {
+      continue;
+    }
+    const linkRecord = valueObjectRecord(linkValue);
+    if (linkRecord === null) continue;
+    const isTile = linkKind === NeoWorldSystemClassKind.TileLayerLink;
+    const linkClassId = requiredValueClassId(linkValue, "layer-link");
+    const layerClassId = resolveWorldLayerLinkTarget({
+      classes: args.classes,
+      linkLabel: `Object-composition layer link value "${linkValue.id}"`,
+      relations: args.relations,
+      sourceClassId: linkClassId
+    }).targetClassId;
+    assertConcreteWorldClass({
+      classId: layerClassId,
+      classes: args.classes,
+      classesById,
+      expectedKind: isTile ? NeoWorldSystemClassKind.TileLayer : NeoWorldSystemClassKind.ObjectLayer,
+      label: `Object-composition layer link value "${linkValue.id}" target`
+    });
+    validateOwnedSparseValue({
+      classesById,
+      expectedClassId: layerClassId,
+      ownerId: linkValue.id,
+      referenceId: optionalNonEmptyString(linkRecord.layerOverrideValueId),
+      referenceLabel: `Object-composition layer link value "${linkValue.id}" layerOverrideValueId`,
+      valuesById
+    });
+    const placementListKey = isTile ? "Tiles" : "Objects";
+    const placementList = referencedValue(
+      linkRecord[placementListKey],
+      valuesById,
+      `Object-composition layer link value "${linkValue.id}" ${placementListKey}`
+    );
+    if (placementList === null) continue;
+    for (const placementId of containmentEntryIds(
+      placementList,
+      containedIds
+    )) {
+      const placement = valuesById.get(placementId);
+      if (placement === void 0) {
+        throw new Error(
+          `Object-composition layer link value "${linkValue.id}" references missing placement "${placementId}".`
+        );
+      }
+      validateWorldPlacementSidecars({
+        classes: args.classes,
+        classesById,
+        importedClassIds: null,
+        isTile,
+        layerClassId,
+        linkValueId: linkValue.id,
+        placement,
+        relations: args.relations,
+        valuesById
+      });
+      reachablePlacementIds.add(placement.id);
+      validatedPlacementIds.add(placement.id);
+    }
+  }
+  for (const value of args.values) {
+    const record3 = valueObjectRecord(value);
+    if (record3 === null) continue;
+    if (optionalNonEmptyString(record3.assetClassId) !== null && !validatedPlacementIds.has(value.id) && !reachablePlacementIds.has(value.id)) {
+      throw new Error(
+        `Class-backed placement value "${value.id}" is not owned by a class-backed layer link.`
+      );
+    }
+  }
+}
+function validateWorldPlacementSidecars(args) {
+  const record3 = valueObjectRecord(args.placement);
+  if (record3 === null) {
+    throw new Error(
+      `Placement value "${args.placement.id}" under layer link "${args.linkValueId}" must store a class record.`
+    );
+  }
+  const assetClassId = optionalNonEmptyString(record3.assetClassId);
+  if (assetClassId === null) {
+    throw new Error(
+      `Class-backed placement value "${args.placement.id}" is missing assetClassId.`
+    );
+  }
+  assertConcreteWorldClass({
+    classId: assetClassId,
+    classes: args.classes,
+    classesById: args.classesById,
+    expectedKind: args.isTile ? NeoWorldSystemClassKind.Tile : NeoWorldSystemClassKind.Object,
+    label: `Placement value "${args.placement.id}" assetClassId`
+  });
+  if (args.importedClassIds !== null && !args.importedClassIds.has(assetClassId)) {
+    throw new Error(
+      `Placement value "${args.placement.id}" uses ${args.isTile ? "tile" : "object"} class "${assetClassId}" that is not imported by its grid.`
+    );
+  }
+  const compatibleLayerIds = effectiveTargetIds({
+    classes: args.classes,
+    relationKind: args.isTile ? InternalRecordRelationKind.WorldTileCompatibleLayer : InternalRecordRelationKind.WorldObjectCompatibleLayer,
+    relations: args.relations,
+    sourceClassId: assetClassId
+  });
+  if (!compatibleLayerIds.has(args.layerClassId)) {
+    throw new Error(
+      `Placement value "${args.placement.id}" asset class "${assetClassId}" is not compatible with layer class "${args.layerClassId}".`
+    );
+  }
+  validateOwnedSparseValue({
+    classesById: args.classesById,
+    expectedClassId: assetClassId,
+    ownerId: args.placement.id,
+    referenceId: optionalNonEmptyString(record3.assetValueId),
+    referenceLabel: `Placement value "${args.placement.id}" assetValueId`,
+    valuesById: args.valuesById
+  });
+}
+function validateOwnedSparseValue(args) {
+  if (args.referenceId === null) return;
+  const value = args.valuesById.get(args.referenceId);
+  if (value === void 0) {
+    throw new Error(
+      `${args.referenceLabel} references missing value "${args.referenceId}".`
+    );
+  }
+  if (!args.classesById.has(args.expectedClassId)) {
+    throw new Error(
+      `${args.referenceLabel} expects missing class "${args.expectedClassId}".`
+    );
+  }
+  if (value.classId !== args.expectedClassId) {
+    throw new Error(
+      `${args.referenceLabel} references value "${value.id}" with class "${String(value.classId)}", expected "${args.expectedClassId}".`
+    );
+  }
+  if (value.containerId !== args.ownerId) {
+    throw new Error(
+      `${args.referenceLabel} references value "${value.id}" owned by "${String(value.containerId)}", expected "${args.ownerId}".`
+    );
+  }
+}
 function assertConcreteWorldClass(args) {
   const schemaClass2 = args.classesById.get(args.classId);
   if (schemaClass2 === void 0) {
@@ -72238,6 +72928,58 @@ function assertConcreteWorldClass(args) {
     throw new Error(`${args.label} must reference a concrete class.`);
   }
 }
+function effectiveTargetIds(args) {
+  return new Set(
+    resolveEffectiveClassRelations(args).map(
+      (relation) => relation.targetRecordId
+    )
+  );
+}
+function worldKindForValue(value, classes) {
+  return typeof value.classId === "string" ? resolveWorldSystemClassKind(value.classId, classes) : null;
+}
+function requiredValueClassId(value, label) {
+  if (typeof value.classId === "string" && value.classId.length > 0) {
+    return value.classId;
+  }
+  throw new Error(`${label} value "${value.id}" is missing classId.`);
+}
+function valueObjectRecord(value) {
+  if (value.value === null || typeof value.value !== "object") return null;
+  if (Array.isArray(value.value)) return null;
+  return value.value;
+}
+function referencedValue(reference2, valuesById, label) {
+  if (reference2 === void 0 || reference2 === null) return null;
+  if (typeof reference2 !== "string" || reference2.length === 0) {
+    throw new Error(`${label} must reference a value id.`);
+  }
+  const value = valuesById.get(reference2);
+  if (value === void 0) {
+    throw new Error(`${label} references missing value "${reference2}".`);
+  }
+  return value;
+}
+function containmentEntryIds(listValue2, containedIds) {
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(listValue2.value)) {
+    for (const valueId of listValue2.value) {
+      if (typeof valueId === "string" && valueId.length > 0) ids.add(valueId);
+    }
+  }
+  for (const valueId of containedIds.get(listValue2.id) ?? []) ids.add(valueId);
+  return [...ids];
+}
+function containedValueIdsByContainer(values) {
+  const result = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (typeof value.containerId !== "string") continue;
+    const ids = result.get(value.containerId) ?? [];
+    ids.push(value.id);
+    result.set(value.containerId, ids);
+  }
+  return result;
+}
 function optionalNonEmptyString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
@@ -80949,6 +81691,16 @@ function assertProjectVersionWholeGraphWritesValid(args) {
   assertStagedUnitySingletonValid(projected, args.changes);
   assertStagedProjectInterfaceValid(projected, args.changes);
   assertStagedTileGridReferencesValid(args.document, projected, args.changes);
+  assertStagedInternalRecordRelationsValid(
+    args.document,
+    projected,
+    args.changes
+  );
+  assertStagedWorldContentLayerBindingsValid(
+    args.document,
+    projected,
+    args.changes
+  );
   assertAnimationClipDocumentValid(
     materializeDeclarationInitializersForAnimationValidation(projected)
   );
@@ -81137,6 +81889,188 @@ function containsDirectValueId(value, ids) {
     (entry) => typeof entry === "string" && ids.has(entry)
   );
 }
+function assertStagedInternalRecordRelationsValid(current, projected, changes) {
+  if (!stagedChangesAffectClassRelations(current, changes)) return;
+  validateInternalRecordRelations({
+    relations: projected.internalRecordRelations ?? [],
+    endpoints: collectProjectDocumentRelationEndpoints(projected),
+    classes: projected.classes
+  });
+}
+function stagedChangesAffectClassRelations(current, changes) {
+  const classesById = new Map(
+    current.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const valuesById = new Map(current.values.map((value) => [value.id, value]));
+  for (const change of changes) {
+    if (change.recordKind === "internal-record-relation") return true;
+    if (change.recordKind === "class") {
+      if (change.operation !== "update") return true;
+      if (change.deleted === true) return true;
+      const before2 = classesById.get(change.recordId);
+      if (before2 === void 0) return true;
+      const after = change.nextData;
+      if (!isPlainRecord4(after)) return true;
+      if (before2.extendsClassId !== after.extendsClassId) return true;
+      continue;
+    }
+    if (change.recordKind !== "value") continue;
+    const before = valuesById.get(change.recordId);
+    if (relationEndpointClassId(before) !== relationEndpointClassId(change.nextData)) {
+      return true;
+    }
+  }
+  return false;
+}
+function assertStagedWorldContentLayerBindingsValid(current, projected, changes) {
+  if (!stagedChangesRequireWorldLayerBindingValidation(current, changes)) {
+    return;
+  }
+  const classes = projected.classes;
+  const relations = projected.internalRecordRelations ?? [];
+  validateWorldContentSidecars({
+    classes,
+    relations,
+    values: projected.values
+  });
+  validateWorldLayerLinkClassTargets({
+    classes,
+    relations,
+    classIds: stagedAffectedWorldLayerLinkClassIds({
+      classes,
+      relations,
+      current,
+      changes
+    })
+  });
+}
+function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
+  const classesById = new Map(
+    current.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  const valuesById = new Map(current.values.map((value) => [value.id, value]));
+  const valueChanges = [];
+  for (const change of changes) {
+    if (change.recordKind === "internal-record-relation") return true;
+    if (change.recordKind === "value") {
+      valueChanges.push(change);
+      continue;
+    }
+    if (change.recordKind !== "class") continue;
+    if (change.operation !== "update") return true;
+    if (change.deleted === true) return true;
+    const before = classesById.get(change.recordId);
+    if (before === void 0) return true;
+    const after = change.nextData;
+    if (!isPlainRecord4(after)) return true;
+    if (before.extendsClassId !== after.extendsClassId) return true;
+    if (before.isAbstract !== after.isAbstract) return true;
+    if (!worldClassSystemBlockIsEqual(before.system, after.system)) return true;
+  }
+  if (valueChanges.length === 0) return false;
+  const graph = createWorldReferenceGraph({
+    classes: current.classes,
+    values: []
+  });
+  for (const change of valueChanges) {
+    const before = valuesById.get(change.recordId);
+    if (hasWorldLayerOverrideMetadata(before) || hasWorldLayerOverrideMetadata(change.nextData)) {
+      return true;
+    }
+    const classIds = [
+      relationEndpointClassId(before),
+      relationEndpointClassId(change.nextData)
+    ].filter((classId) => classId !== void 0);
+    for (const classId of classIds) {
+      const worldKind = resolveWorldKindFromClassMap(
+        classId,
+        graph.classesById
+      );
+      if (worldKind === NeoWorldSystemClassKind.TileLayerLink) return true;
+      if (worldKind === NeoWorldSystemClassKind.ObjectLayerLink) return true;
+    }
+  }
+  return false;
+}
+function stagedAffectedWorldLayerLinkClassIds(args) {
+  const baseRelationsById = new Map(
+    (args.current.internalRecordRelations ?? []).map((relation) => [
+      relation.id,
+      relation
+    ])
+  );
+  const roots = /* @__PURE__ */ new Set();
+  const changedClassIds = /* @__PURE__ */ new Set();
+  for (const change of args.changes) {
+    if (change.recordKind === "class") {
+      changedClassIds.add(change.recordId);
+      roots.add(change.recordId);
+      continue;
+    }
+    if (change.recordKind !== "internal-record-relation") continue;
+    const candidates = [
+      baseRelationsById.get(change.recordId),
+      change.nextData
+    ];
+    for (const candidate of candidates) {
+      if (!isPlainRecord4(candidate)) continue;
+      const relationKind = candidate.relationKind;
+      if (typeof relationKind !== "string") continue;
+      if (!isStagedWorldLayerLinkTargetRelationKind(relationKind)) continue;
+      const sourceRecordId = candidate.sourceRecordId;
+      if (typeof sourceRecordId !== "string") continue;
+      roots.add(sourceRecordId);
+    }
+  }
+  for (const relation of args.relations) {
+    if (!isStagedWorldLayerLinkTargetRelationKind(relation.relationKind)) {
+      continue;
+    }
+    if (!changedClassIds.has(relation.targetRecordId)) continue;
+    roots.add(relation.sourceRecordId);
+  }
+  const affected = new Set(roots);
+  let added = true;
+  while (added) {
+    added = false;
+    for (const schemaClass2 of args.classes) {
+      if (schemaClass2.extendsClassId === void 0) continue;
+      if (!affected.has(schemaClass2.extendsClassId)) continue;
+      if (affected.has(schemaClass2.id)) continue;
+      affected.add(schemaClass2.id);
+      added = true;
+    }
+  }
+  return affected;
+}
+function isStagedWorldLayerLinkTargetRelationKind(relationKind) {
+  if (relationKind === InternalRecordRelationKind.WorldTileLayerLinkTarget) {
+    return true;
+  }
+  return relationKind === InternalRecordRelationKind.WorldObjectLayerLinkTarget;
+}
+function worldClassSystemBlockIsEqual(before, after) {
+  return projectRecordDataIsSemanticallyEqual(
+    { system: before },
+    { system: after }
+  );
+}
+function hasWorldLayerOverrideMetadata(record3) {
+  if (!isPlainRecord4(record3)) return false;
+  const value = record3.value;
+  if (!isPlainRecord4(value)) return false;
+  return typeof value.layerOverrideValueId === "string";
+}
+function relationEndpointClassId(record3) {
+  if (!isPlainRecord4(record3)) return void 0;
+  if (typeof record3.classId === "string") return record3.classId;
+  if (typeof record3.typeId === "string") return record3.typeId;
+  return void 0;
+}
+function isPlainRecord4(value) {
+  if (value === null || typeof value !== "object") return false;
+  return !Array.isArray(value);
+}
 function assertStagedProjectInterfaceValid(projected, changes) {
   const relevant = changes.filter(
     (change) => INTERFACE_VALIDATED_RECORD_KINDS.has(change.recordKind)
@@ -81254,6 +82188,10 @@ var INTERFACE_VALIDATED_RECORD_KINDS;
 var init_project_version_whole_graph_validation = __esm({
   "../src/database/project-version-whole-graph-validation.ts"() {
     "use strict";
+    init_internal_record_relations();
+    init_world_content_sidecar_validation();
+    init_world_layer_link_target();
+    init_core();
     init_animation_clips();
     init_projectInterfaceValidation();
     init_project_schema_identifier_validation();
@@ -81264,6 +82202,7 @@ var init_project_version_whole_graph_validation = __esm({
     init_init_backed_value_materialization();
     init_world_system_classes();
     init_project_world_reference_graph();
+    init_project_record_semantics();
     INTERFACE_VALIDATED_RECORD_KINDS = /* @__PURE__ */ new Set(["member", "class", "constructor", "interface"]);
   }
 });
@@ -81556,6 +82495,7 @@ function replayStoredConstructionV4(args) {
     );
   }
   if (args.evaluate === false) return /* @__PURE__ */ new Map();
+  compilePulledUncompiledConstructorsV4(document, compilationProject);
   assertPulledConstructorsCompiled(document);
   const compiledDependencies = /* @__PURE__ */ new Set();
   let materialized;
@@ -81598,6 +82538,34 @@ function replayStoredConstructionV4(args) {
     ])
   );
 }
+function compilePulledUncompiledConstructorsV4(document, compilationProject) {
+  const uncompiled = (document.constructors ?? []).filter(
+    (constructor2) => !isNeoClassConstructor(constructor2)
+  );
+  if (uncompiled.length === 0) return;
+  const project = compilationProject ?? createNeoScriptCompilationProject({
+    project: document.project,
+    projectFiles: document.projectFiles,
+    members: document.members,
+    classes: document.classes,
+    enums: document.enums,
+    interfaces: document.interfaces,
+    constructors: document.constructors ?? []
+  });
+  const compileArgs = {
+    project: document.project,
+    projectFiles: document.projectFiles,
+    members: document.members,
+    classes: document.classes,
+    enums: document.enums,
+    interfaces: document.interfaces,
+    constructors: document.constructors ?? [],
+    compilationProject: project
+  };
+  for (const constructor2 of uncompiled) {
+    compileConstructorRecord({ ...compileArgs, constructor: constructor2 });
+  }
+}
 function valueInitializerCompilationSites(document) {
   const cached = pulledValueInitializerCompilationSites.get(document);
   if (cached !== void 0) return cached;
@@ -81713,13 +82681,55 @@ function compilePulledMemberInitializerBodyV4(document, memberId, compilationPro
   });
 }
 function readPulledProjectDocumentV4(records2) {
-  return readProjectDocument(
-    // Replay compilation mutates authored `init` envelopes with transient IR.
-    // Keep that evaluator-local: the input records are also the source commit
-    // payload, where compiled bodies are deliberately absent.
-    structuredClone(pulledProjectDocumentRaw(replayWorkspace(records2))),
-    { constructors: "authored-or-compiled" }
+  const raw = structuredClone(
+    pulledProjectDocumentRaw(replayWorkspace(records2))
+  );
+  return readProjectDocument(completeProspectiveLocalizedTexts(raw), {
+    constructors: "authored-or-compiled",
+    identities: "prospective"
+  });
+}
+function completeProspectiveLocalizedTexts(raw) {
+  const localizedTexts = raw.localizedTexts;
+  if (!Array.isArray(localizedTexts)) return raw;
+  const incomplete = localizedTexts.find((text) => !isLocalizedText(text));
+  if (incomplete === void 0) return raw;
+  const config = localizedTextEnvelopeConfig(
+    raw.localizationConfig,
+    prospectiveLocalizedTextId(incomplete)
   );
+  return {
+    ...raw,
+    localizedTexts: localizedTexts.map(
+      (text) => isLocalizedText(text) ? text : completeLocalizedTextCreateEnvelope(text, config)
+    )
+  };
+}
+function localizedTextEnvelopeConfig(value, textId) {
+  if (!isObjectRecord2(value)) {
+    throw new Error(
+      `Localized text "${textId}" needs the server create envelope, but the project carries no localization config record to mint it from.`
+    );
+  }
+  if (typeof value.mainLocale !== "string") {
+    throw new Error(
+      `Localized text "${textId}" needs the server create envelope, but the project localization config declares no main locale.`
+    );
+  }
+  if (typeof value.mainLocaleDefaultStatusId !== "string") {
+    throw new Error(
+      `Localized text "${textId}" needs the server create envelope, but the project localization config declares no main-locale default status.`
+    );
+  }
+  return {
+    mainLocale: value.mainLocale,
+    mainLocaleDefaultStatusId: value.mainLocaleDefaultStatusId
+  };
+}
+function prospectiveLocalizedTextId(value) {
+  if (!isObjectRecord2(value)) return "<non-object>";
+  if (typeof value.id !== "string") return "<unidentified>";
+  return value.id;
 }
 function replayWorkspace(records2) {
   const stateRecords = {};
@@ -81758,6 +82768,7 @@ var init_initializer_replay = __esm({
     init_value_row_owner_members();
     init_inheritance();
     init_project_document_read();
+    init_localization2();
     init_server_preparation_preflight();
     init_projection();
     init_constructors2();
@@ -82842,6 +83853,13 @@ function constructorArgumentValueSlices(authoredSlice) {
     );
   });
 }
+function unattachedAuthoredRowId(authoredSlice) {
+  if (authoredSlice === void 0) return null;
+  const match = LEADING_AUTHORED_ROW_ID.exec(
+    normalizeInitializerSource(authoredSlice)
+  );
+  return match?.[1] ?? null;
+}
 function initializerExpressionSlice(authoredSlice) {
   if (authoredSlice === void 0) return void 0;
   let text = normalizeInitializerSource(authoredSlice);
@@ -83212,6 +84230,12 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     memberClassName(context, resolvedMember),
     bindingRuntimeIdentifiers(context, source)
   )) {
+    const unattachedId = annotated.id === null ? unattachedAuthoredRowId(authoredSlice) : null;
+    if (unattachedId !== null) {
+      throw new Error(
+        `Value ${path} in ${source.label} writes @id(${JSON.stringify(unattachedId)}) on part of a computed expression rather than on the row. Parenthesize the expression so the annotation names the whole row.`
+      );
+    }
     if (annotated.id === null && isPendingId(valueId) && !context.pendingValueIdentitySites.has(valueId)) {
       context.pendingValueIdentitySites.set(valueId, {
         id: valueId,
@@ -87233,7 +88257,7 @@ function memberDefaultBody(member) {
   if (!("value" in defaultValue)) return null;
   return defaultValue.value;
 }
-var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY, MEMBER_KIND_LIST, MEMBER_KIND_CLASS, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
+var INFERRED_GENERIC_CLASS_PREFIX, MEMBER_KIND_DICTIONARY, MEMBER_KIND_LIST, MEMBER_KIND_CLASS, LEADING_AUTHORED_ROW_ID, CANONICAL_CONSTRUCTOR_INLINE_WIDTH;
 var init_value_sources = __esm({
   "src/project-source/value-sources.ts"() {
     "use strict";
@@ -87260,6 +88284,7 @@ var init_value_sources = __esm({
     MEMBER_KIND_DICTIONARY = 5;
     MEMBER_KIND_LIST = 6;
     MEMBER_KIND_CLASS = 7;
+    LEADING_AUTHORED_ROW_ID = /^@id\(\s*"((?:[^"\\]|\\.)*)"\s*\)/;
     CANONICAL_CONSTRUCTOR_INLINE_WIDTH = 88;
   }
 });