@neocompose/cli 0.23.0 → 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"() {
@@ -55296,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])
 )) {
@@ -55311,6 +55328,7 @@ function buildEvaluatorBaseIndexes(members, values, valueById = new Map(
     declaredListByArray: /* @__PURE__ */ new WeakMap(),
     rowsBySourceValueId: /* @__PURE__ */ new Map(),
     ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
+    ownershipDistancesByRowId: /* @__PURE__ */ new Map(),
     ownedValueAttachmentsByValueId: /* @__PURE__ */ new Map(),
     memberByRowId: /* @__PURE__ */ new Map()
   };
@@ -55343,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,
@@ -55359,7 +55379,11 @@ function evaluatorIndexes(ctx) {
     declaredListByArray: liveListIndexes?.declared ?? /* @__PURE__ */ new WeakMap(),
     rowsBySourceValueId: /* @__PURE__ */ new Map(),
     baseRowsBySourceValueId: base?.rowsBySourceValueId,
-    ownershipRootIdsByRowId: /* @__PURE__ */ new Map(),
+    // 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()
   };
@@ -55413,6 +55437,7 @@ function indexEvaluatorRow(indexes, row, allowBaseShadow = false) {
     }
   }
   indexes.ownershipRootIdsByRowId.clear();
+  indexes.ownershipDistancesByRowId.clear();
   indexes.memberByRowId.clear();
   if (indexes.indexedRowIds.has(row.id) || !allowBaseShadow && indexes.baseIndexedRowIds?.has(row.id) === true) {
     return;
@@ -55484,6 +55509,29 @@ function evaluatorOwnershipRootIds(rowId, indexes) {
   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,
@@ -55506,6 +55554,28 @@ function resolveRuntimeReferenceRow(sourceValueId, ctx) {
   );
   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.`
   );
@@ -61636,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";
@@ -61675,6 +61745,7 @@ var init_evaluateNSGetter = __esm({
       producedStringCharacters: 1024 * 1024
     });
     liveListIndexesByProject = /* @__PURE__ */ new WeakMap();
+    evaluatorOwnershipCachesByBase = /* @__PURE__ */ new WeakMap();
     MAX_CONSTRUCTION_DEPTH = 64;
     MAX_LOOP_ITERATIONS = 1e4;
     LazyValueOverlay = class extends Map {
@@ -72405,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";
@@ -72415,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) {
@@ -72432,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;
 }
@@ -81143,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)
   );
@@ -81331,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)
@@ -81448,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();
@@ -81458,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"]);
   }
 });
@@ -81750,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;
@@ -81792,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;