@neocompose/cli 0.47.0 → 0.47.1

package/dist/neo.mjs

@@ -43513,7 +43513,13 @@ var init_member_kind_taxonomy = __esm({
       [15 /* Vector2Int */]: [1 /* Direct */, BINDABLE, "vector", 2, 7],
       [16 /* Vector3 */]: [1 /* Direct */, BINDABLE, "vector", 3, 8],
       [17 /* Vector3Int */]: [1 /* Direct */, BINDABLE, "vector", 3, 9],
-      [18 /* DialogueLookup */]: [1 /* Direct */, STORED, "core", null, 16],
+      [18 /* DialogueLookup */]: [
+        1 /* Direct */,
+        STORED,
+        "collection",
+        null,
+        16
+      ],
       [19 /* Color */]: [1 /* Direct */, BINDABLE, "core", null, 10],
       [20 /* Decimal */]: [1 /* Direct */, BINDABLE, "number", null, 5],
       [21 /* Generic */]: [2 /* Contextual */, STORED, "core", null, null],
@@ -44000,6 +44006,56 @@ var init_neoscript_types = __esm({
   }
 });
 
+// ../src/models/neoscript/neoscript-compiler-revision.ts
+function isAcceptedNeoScriptCompilerRevision(stamp, rollout = ACTIVE_NEOSCRIPT_COMPILER_REVISION_ROLLOUT) {
+  if (stamp === NEOSCRIPT_COMPILER_REVISION) return true;
+  if (rollout === null) return false;
+  if (stamp === void 0) return true;
+  if (typeof stamp !== "number") return false;
+  if (!Number.isSafeInteger(stamp)) return false;
+  return stamp >= 1 && stamp < rollout.revision;
+}
+function describeNeoScriptCompilerRevisionRejection(stamp, rollout = ACTIVE_NEOSCRIPT_COMPILER_REVISION_ROLLOUT) {
+  const carried = stamp === void 0 ? "carries no compiler revision stamp" : `carries compiler revision ${JSON.stringify(stamp)}`;
+  const remedy = rollout === null ? `push the project source again or queue a recompile with \`npm run compiler-revision:mint\`` : `let migration ${rollout.migrationId} finish or push the project source again`;
+  return `${carried}; this build requires exactly revision ${String(NEOSCRIPT_COMPILER_REVISION)} \u2014 ${remedy}`;
+}
+function collectNeoScriptCompiledBodyStamps(record4) {
+  const stamps = [];
+  const visit = (node, path) => {
+    if (Array.isArray(node)) {
+      for (let index = 0; index < node.length; index += 1) {
+        visit(node[index], `${path}[${String(index)}]`);
+      }
+      return;
+    }
+    if (typeof node !== "object" || node === null) return;
+    const object2 = node;
+    if (isCompiledBodyShape(object2)) {
+      stamps.push({ path, stamp: object2.compilerRevision });
+    }
+    for (const key of Object.keys(object2)) {
+      visit(object2[key], path === "" ? key : `${path}.${key}`);
+    }
+  };
+  visit(record4, "");
+  return stamps;
+}
+function isCompiledBodyShape(object2) {
+  if (!Array.isArray(object2.parameters)) return false;
+  if (!Array.isArray(object2.instructions)) return false;
+  return Object.prototype.hasOwnProperty.call(object2, "typeInfo");
+}
+var ACTIVE_NEOSCRIPT_COMPILER_REVISION_ROLLOUT;
+var init_neoscript_compiler_revision = __esm({
+  "../src/models/neoscript/neoscript-compiler-revision.ts"() {
+    "use strict";
+    init_src();
+    ACTIVE_NEOSCRIPT_COMPILER_REVISION_ROLLOUT = // <neoscript-compiler-revision-rollout>
+    { migrationId: "neoscript-compiler-revision-13", revision: 13 };
+  }
+});
+
 // ../src/models/neoscript/neoscript-guards.ts
 function isNSTypeInfoBase(value) {
   const v = value;
@@ -44506,15 +44562,10 @@ function isNSConditionalBranch(value) {
 function isNSFunctionWithReturnType(value) {
   const v = value;
   if (typeof v !== "object" || v === null) return false;
-  if (v.compilerRevision !== void 0 && (!Number.isSafeInteger(v.compilerRevision) || v.compilerRevision < 1 || v.compilerRevision > NEOSCRIPT_COMPILER_REVISION)) {
-    return false;
-  }
+  if (!isAcceptedNeoScriptCompilerRevision(v.compilerRevision)) return false;
   if (!Array.isArray(v.parameters)) return false;
   if (!v.parameters.every(isNSVariable)) return false;
   if (!isNSInstructions(v.instructions)) return false;
-  if ((v.compilerRevision ?? 1) < NEOSCRIPT_COMPILER_REVISION && (v.compilerRevision ?? 1) < minimumNeoScriptCompilerRevisionForIR(v.instructions)) {
-    return false;
-  }
   if (!isNSTypeInfo(v.typeInfo)) return false;
   return true;
 }
@@ -44968,38 +45019,6 @@ function isNSInstructionTry(value) {
 function isNSInstruction(value) {
   return isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value) || isNSInstructionAddActionListener(value) || isNSInstructionRemoveActionListener(value);
 }
-function minimumNeoScriptCompilerRevisionForIR(node, visited = /* @__PURE__ */ new Set()) {
-  if (Array.isArray(node)) {
-    let minimum2 = 1;
-    for (const entry of node) {
-      minimum2 = Math.max(
-        minimum2,
-        minimumNeoScriptCompilerRevisionForIR(entry, visited)
-      );
-    }
-    return minimum2;
-  }
-  if (typeof node !== "object" || node === null) return 1;
-  if (visited.has(node)) return 1;
-  visited.add(node);
-  const discriminatorRevision = "type" in node && typeof node.type === "string" ? MINIMUM_REVISION_BY_IR_DISCRIMINATOR.get(node.type) ?? 1 : 1;
-  const fallbackRevision = "missingMemberFallback" in node && node.missingMemberFallback === "valueEquality" ? 12 : 1;
-  const countPredicateRevision = "type" in node && node.type === "count" /* count */ && "info" in node && typeof node.info === "object" && node.info !== null && "function" in node.info && node.info.function !== void 0 && node.info.function !== null ? 13 : 1;
-  let minimum = Math.max(
-    discriminatorRevision,
-    fallbackRevision,
-    countPredicateRevision
-  );
-  const isLiteralValue = "typeInfo" in node && "value" in node && !("type" in node);
-  for (const [key, child] of Object.entries(node)) {
-    if (isLiteralValue && key === "value") continue;
-    minimum = Math.max(
-      minimum,
-      minimumNeoScriptCompilerRevisionForIR(child, visited)
-    );
-  }
-  return minimum;
-}
 function isNSInstructions(value) {
   return Array.isArray(value) && value.every(isNSInstruction);
 }
@@ -45046,11 +45065,11 @@ function isNSVoidBody(value) {
   if (value.typeInfo.type !== 0 /* Null */) return false;
   return value.typeInfo.required === true;
 }
-var NS_STRING_OPS, NS_DECIMAL_OPS, NS_MATH_OPS, MINIMUM_REVISION_BY_IR_DISCRIMINATOR;
+var NS_STRING_OPS, NS_DECIMAL_OPS, NS_MATH_OPS;
 var init_neoscript_guards = __esm({
   "../src/models/neoscript/neoscript-guards.ts"() {
     "use strict";
-    init_src();
+    init_neoscript_compiler_revision();
     init_member_kinds();
     init_core();
     init_neoscript_types();
@@ -45079,21 +45098,6 @@ var init_neoscript_guards = __esm({
       "sign",
       "sqrt"
     ];
-    MINIMUM_REVISION_BY_IR_DISCRIMINATOR = /* @__PURE__ */ new Map([
-      ["for" /* for */, 4],
-      ["forEach" /* forEach */, 4],
-      ["break" /* break */, 4],
-      ["continue" /* continue */, 4],
-      ["switch" /* switch */, 5],
-      ["try" /* try */, 6],
-      ["callDelegate" /* callDelegate */, 7],
-      ["addActionListener" /* addActionListener */, 8],
-      ["removeActionListener" /* removeActionListener */, 8],
-      ["callAction" /* callAction */, 8],
-      ["conditional" /* conditional */, 12],
-      ["delegateClosure" /* delegateClosure */, 12],
-      ["indexOf" /* indexOf */, 13]
-    ]);
   }
 });
 
@@ -45281,6 +45285,7 @@ var init_neoscript = __esm({
     init_neoscript_guards();
     init_parameter_defaults();
     init_type_info_compatibility();
+    init_neoscript_compiler_revision();
   }
 });
 
@@ -57360,6 +57365,7 @@ function pendingGroupIdentity(global, kind, ordinal, name) {
 }
 function placeholderBoolGetter() {
   return {
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION,
     parameters: [],
     typeInfo: { type: 1, required: true },
     instructions: [
@@ -67995,6 +68001,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
       resolveMemberDeclaredTypeInfoInternal(collection, members, nextSeen)
     );
   }
+  if (resolved.kind === 9 /* Lookup */) return null;
   if (!memberKindSupportsStorage(resolved.kind)) return null;
   if (resolved.kind === 21 /* Generic */) return null;
   return {
@@ -75491,25 +75498,16 @@ function evalDeclaredListIndex(info, scope, ctx) {
 function prepareCollectionCallback(callback, parentScope, ctx, isList, returnContract, onPredicateMatch) {
   const metrics = ctx.__collectionCallbackPreparationMetrics;
   if (metrics !== void 0) metrics.bodyValidations += 1;
-  const compilerRevision = callback.compilerRevision ?? 1;
-  if (!Number.isSafeInteger(compilerRevision)) {
+  const compilerRevision = callback.compilerRevision;
+  if (!isAcceptedNeoScriptCompilerRevision(compilerRevision)) {
     throw new NSGetterRuntimeError(
-      "Collection callback compiler revision must be a safe integer."
-    );
-  }
-  if (compilerRevision < 1) {
-    throw new NSGetterRuntimeError(
-      "Collection callback compiler revision must be at least 1."
-    );
-  }
-  if (compilerRevision > NEOSCRIPT_COMPILER_REVISION) {
-    throw new NSGetterRuntimeError(
-      `Collection callback compiler revision ${String(compilerRevision)} is newer than supported revision ${String(NEOSCRIPT_COMPILER_REVISION)}.`
+      `Collection callback ${describeNeoScriptCompilerRevisionRejection(compilerRevision)}.`
     );
   }
   if (!isNSFunctionWithReturnType(callback)) {
+    const stamp = compilerRevision === void 0 ? "(unstamped)" : String(compilerRevision);
     throw new NSGetterRuntimeError(
-      `Collection callback body metadata is invalid for compiler revision ${String(compilerRevision)}.`
+      `Collection callback body metadata is invalid for compiler revision ${stamp}.`
     );
   }
   const parameters = callback.parameters;
@@ -79535,7 +79533,6 @@ var init_evaluateNSGetter = __esm({
     init_neoscript();
     init_NSGetterRuntimeError();
     init_value_row_owner_members();
-    init_src();
     init_decimal();
     init_members();
     init_packed_value_encoding();
@@ -80722,10 +80719,29 @@ function resolveVirtualInstanceGraph(args) {
     return comparison;
   };
   const rootLocation = resolvePath(ROOT_PATH, args.instanceRoot.id, null);
+  const canonicalReceiver = (id2) => locationsById.get(id2)?.virtualRow.id ?? id2;
+  for (const location3 of locationsByPath.values()) {
+    if (location3.materializedRow !== null) continue;
+    if (location3.member.kind !== 25 /* NSDelegate */) continue;
+    const effective = rowsById.get(location3.id);
+    effective.value = remapMemberDelegateReceiver(effective.value, (id2) => {
+      const target = expansion.nodesByExpandedId.get(id2);
+      return target === void 0 ? id2 : locationsByPath.get(target.pathKey)?.id ?? target.virtualId;
+    });
+  }
+  const compareLeafContent = (location3) => location3.materializedRow !== null && semanticEqual(
+    normalizeLeafPayload(
+      location3.materializedRow,
+      location3.member,
+      canonicalReceiver
+    ),
+    normalizeLeafPayload(location3.virtualRow, location3.member)
+  );
   return {
     instanceRootId: args.instanceRoot.id,
     pinnedRootSchemaKeys: args.pinnedRootSchemaKeys,
     compareCreationProvenance,
+    compareLeafContent,
     rowsById,
     locationsById,
     locationsByPath,
@@ -80739,7 +80755,9 @@ function mergeExpandedAndMaterializedRow(expanded, materialized) {
   const expandedClone = cloneRow(expanded);
   if (materialized === null) return expandedClone;
   const materializedClone = cloneRow(materialized);
-  return isLiteralValueContent(materialized) ? overlayLiteralValueContent(expandedClone, materializedClone) : { ...expandedClone, ...materializedClone };
+  const merged = isLiteralValueContent(materialized) ? overlayLiteralValueContent(expandedClone, materializedClone) : { ...expandedClone, ...materializedClone };
+  if (merged.sourceValueId === materialized.id) delete merged.sourceValueId;
+  return merged;
 }
 function firstUnattributableExpansionMember(expansion) {
   for (const node of expansion.nodesByPath.values()) {
@@ -81047,10 +81065,7 @@ function planCollapseVirtualInstance(args) {
     if (named === void 0) return false;
     if (!isLiteralValueContent(stored)) return false;
     if (!isLiteralValueContent(named)) {
-      return semanticEqual(
-        normalizeLeafPayload(stored, location3.member),
-        normalizeLeafPayload(location3.virtualRow, location3.member)
-      );
+      return args.graph.compareLeafContent(location3);
     }
     return semanticEqual(
       normalizeLeafPayload(named, location3.member),
@@ -81182,6 +81197,7 @@ function planCollapseVirtualInstance(args) {
         contentEqual &&= bothArrays;
         contentEqual &&= lengthsAgree;
         for (let index = 0; index < (stored2?.length ?? 0); index += 1) {
+          if (stored2?.[index] === null && virtual?.[index] === null) continue;
           const child = args.graph.locationsByPath.get(
             appendPath(location3.pathKey, { kind: "list", index })
           );
@@ -81220,10 +81236,7 @@ function planCollapseVirtualInstance(args) {
         protectedSubtree ||= facts.protected;
       }
     } else {
-      const leafEqual = semanticEqual(
-        normalizeLeafPayload(real, location3.member),
-        normalizeLeafPayload(location3.virtualRow, location3.member)
-      );
+      const leafEqual = args.graph.compareLeafContent(location3);
       defaultEqual &&= leafEqual;
       contentEqual &&= leafEqual;
     }
@@ -81481,12 +81494,25 @@ function sparsifyConstructedInstance(args) {
       Object.entries(value).map(([key, entry]) => [key, remap(entry)])
     );
   };
+  const remapReceiver = (id2) => {
+    const retainedId = nextIdById.get(id2);
+    if (retainedId !== void 0) return retainedId;
+    const receiver = graph.locationsById.get(id2);
+    if (receiver === void 0) return id2;
+    return args.virtualValueIdForSource?.(
+      args.constructed.root.id,
+      receiver.sourceIdentity
+    ) ?? receiver.virtualRow.id;
+  };
   const rewrite = (row) => {
     const literal3 = literalRow(row);
+    const payload = updatedValueById.get(row.id) ?? literal3.value;
+    const member = graph.locationsById.get(row.id)?.member ?? materializedGraph.ownerForValue(row.id);
+    const value = member?.kind === 25 /* NSDelegate */ && isMemberDelegateTarget(payload) ? remapMemberDelegateReceiver(payload, remapReceiver) : remap(payload);
     return {
       ...literal3,
       id: nextIdById.get(row.id) ?? row.id,
-      value: remap(updatedValueById.get(row.id) ?? literal3.value),
+      value,
       ...literal3.constructorArgs === void 0 ? {} : {
         constructorArgs: remap(literal3.constructorArgs)
       },
@@ -81844,6 +81870,9 @@ function rewriteExpandedRow(node, expansion) {
       (childId) => typeof childId === "string" ? rewrite(childId) : childId
     );
   }
+  if (node.member.kind === 25 /* NSDelegate */) {
+    row.value = remapMemberDelegateReceiver(row.value, rewrite);
+  }
   if (typeof row.containerId === "string") {
     row.containerId = rewrite(row.containerId);
   }
@@ -81880,7 +81909,12 @@ function sparseParentBody(segment, childId) {
     "A positional List override materializes the List atomically, not as a sparse child spine."
   );
 }
-function normalizeLeafPayload(row, member) {
+function remapMemberDelegateReceiver(value, remap) {
+  if (!isMemberDelegateTarget(value) || value.valueId === null) return value;
+  const valueId = remap(value.valueId);
+  return valueId === value.valueId ? value : { ...value, valueId };
+}
+function normalizeLeafPayload(row, member, remapReceiver = (id2) => id2) {
   const literal3 = literalRow(row);
   if (isMemberListBase(member) || isMemberDictionaryBase(member)) {
     return {
@@ -81889,7 +81923,8 @@ function normalizeLeafPayload(row, member) {
       constructorArgs: literal3.constructorArgs ?? {}
     };
   }
-  return { value: literal3.value, classId: literal3.classId ?? null };
+  const value = member.kind === 25 /* NSDelegate */ ? remapMemberDelegateReceiver(literal3.value, remapReceiver) : literal3.value;
+  return { value, classId: literal3.classId ?? null };
 }
 function compareContextualCreationProvenance(left, right, context) {
   const effectiveType = (row) => {
@@ -83670,10 +83705,18 @@ function readArrayField(source, key, isValid) {
   }
   if (value.every(isValid)) return value;
   const invalidIndex = value.findIndex((item) => !isValid(item));
+  const invalidItem = value[invalidIndex];
   throw new Error(
-    `Convex project document field "${key}" has an invalid shape at index ${invalidIndex}: ${describeInvalidReadItem(value[invalidIndex])}.`
+    `Convex project document field "${key}" has an invalid shape at index ${invalidIndex}: ${describeInvalidReadItem(invalidItem)}${describeRejectedCompilerRevision(invalidItem)}.`
   );
 }
+function describeRejectedCompilerRevision(value) {
+  for (const body of collectNeoScriptCompiledBodyStamps(value)) {
+    if (isAcceptedNeoScriptCompilerRevision(body.stamp)) continue;
+    return `; NeoScript compiler revision rejection: ${body.path} ${describeNeoScriptCompilerRevisionRejection(body.stamp)}`;
+  }
+  return "";
+}
 function readOptionalArrayField(source, key, isValid) {
   if (!Object.prototype.hasOwnProperty.call(source, key)) return [];
   return readArrayField(source, key, isValid);
@@ -83718,6 +83761,7 @@ var init_project_document_read = __esm({
     init_variants2();
     init_dialogue();
     init_enum2();
+    init_neoscript();
     init_interfaces();
     init_files();
     init_localization2();
@@ -84454,6 +84498,202 @@ var init_primary_localized_text_writes = __esm({
   }
 });
 
+// ../src/database/neo-script-derived-bodies.ts
+function cloneAndStripClientDerivedBodies(change) {
+  if (change.operation === "delete" || change.nextData === void 0) {
+    return { ...change };
+  }
+  return {
+    ...change,
+    nextData: stripClientDerivedBodies(change.recordKind, change.nextData)
+  };
+}
+function stripClientDerivedBodies(recordKind, nextData) {
+  const record4 = asRecord2(nextData);
+  return record4 === null ? nextData : strippedClone(recordKind, record4);
+}
+function hasPendingNeoScriptDerivation(recordKind, data) {
+  const record4 = asRecord2(data);
+  if (record4 === null) return false;
+  return collectDerivedBodySites(recordKind, record4).some(
+    (site) => site.authored && !(site.key in site.container)
+  );
+}
+function strippedClone(recordKind, record4) {
+  const next = structuredClone(record4);
+  const container = asRecord2(next);
+  if (container === null) return next;
+  for (const site of collectDerivedBodySites(recordKind, container)) {
+    delete site.container[site.key];
+  }
+  return next;
+}
+function collectDerivedBodySites(recordKind, record4) {
+  const sites = [];
+  if (recordKind === "migration") {
+    sites.push({
+      container: record4,
+      key: "action",
+      authored: typeof record4.code === "string"
+    });
+    return sites;
+  }
+  if (recordKind === "dialogue-group") {
+    collectConditionSites(record4.conditions, sites);
+    return sites;
+  }
+  if (recordKind === "dialogue-node") {
+    collectDialogueNodeSites(record4, sites);
+    return sites;
+  }
+  if (recordKind === "constructor") {
+    sites.push({ container: record4, key: "action", authored: true });
+    sites.push({
+      container: record4,
+      key: "compiledBaseArguments",
+      authored: false
+    });
+    sites.push({
+      container: record4,
+      key: "compiledBaseInitializerFields",
+      authored: false
+    });
+    return sites;
+  }
+  if (recordKind === "value") {
+    collectInitializerSite(record4, sites);
+    collectDelegateClosureSite(record4, sites, true);
+    collectInlineDelegateArgumentSites(record4, sites);
+    return sites;
+  }
+  if (recordKind !== "member") return sites;
+  if (record4.kind === 10 /* NSProperty */) {
+    sites.push({
+      container: record4,
+      key: "getter",
+      authored: typeof record4.code === "string"
+    });
+    sites.push({
+      container: record4,
+      key: "setter",
+      authored: typeof record4.setterCode === "string"
+    });
+  }
+  if (record4.kind === 23 /* NSFunction */) {
+    sites.push({
+      container: record4,
+      key: "action",
+      authored: typeof record4.code === "string"
+    });
+  }
+  if (record4.kind === 25 /* NSDelegate */) {
+    collectDelegateClosureSite(asRecord2(record4.defaultValue), sites, false);
+  }
+  collectInitializerSite(asRecord2(record4.defaultValue), sites);
+  return sites;
+}
+function collectDialogueNodeSites(node, sites) {
+  collectConditionSites(node.conditions, sites);
+  collectTextVariableSites(node.variables, sites);
+  if (Array.isArray(node.actions)) {
+    for (const actionValue2 of node.actions) {
+      const logic = asRecord2(asRecord2(actionValue2)?.logic);
+      if (logic === null) continue;
+      if (logic.type !== 1 /* Code */) continue;
+      if (typeof logic.code !== "string") continue;
+      sites.push({ container: logic, key: "action", authored: true });
+    }
+  }
+  if (Array.isArray(node.outcomes)) {
+    for (const outcomeValue of node.outcomes) {
+      collectConditionSites(asRecord2(outcomeValue)?.conditions, sites);
+    }
+  }
+  const options = asRecord2(node.optionSettings)?.options;
+  if (!Array.isArray(options)) return;
+  for (const optionValue of options) {
+    const option = asRecord2(optionValue);
+    if (option === null) continue;
+    collectTextVariableSites(option.variables, sites);
+    const settings = asRecord2(option.settings);
+    if (settings === null) continue;
+    collectConditionSites(settings.conditions, sites);
+    collectConditionSites(settings.selectableConditions, sites);
+  }
+}
+function collectConditionSites(value, sites) {
+  if (!Array.isArray(value)) return;
+  for (const conditionValue of value) {
+    const condition = asRecord2(conditionValue);
+    if (condition === null) continue;
+    if (condition.type !== 1 /* Code */) continue;
+    if (typeof condition.code !== "string") continue;
+    sites.push({ container: condition, key: "getter", authored: true });
+  }
+}
+function collectTextVariableSites(value, sites) {
+  const variables = asRecord2(value);
+  if (variables === null) return;
+  for (const variableValue of Object.values(variables)) {
+    const variable2 = asRecord2(variableValue);
+    if (variable2 === null) continue;
+    if (typeof variable2.code !== "string") continue;
+    sites.push({ container: variable2, key: "getter", authored: true });
+  }
+}
+function collectDelegateClosureSite(container, sites, authored) {
+  const delegate = asRecord2(container?.value);
+  if (delegate === null) return;
+  if (typeof delegate.code !== "string") return;
+  sites.push({ container: delegate, key: "action", authored });
+}
+function collectInlineDelegateArgumentSites(record4, sites) {
+  const constructorArgs = asRecord2(record4.constructorArgs);
+  if (constructorArgs === null) return;
+  for (const argument2 of Object.values(constructorArgs)) {
+    const closure = asRecord2(argument2);
+    if (closure === null) continue;
+    if (typeof closure.code !== "string") continue;
+    sites.push({ container: closure, key: "action", authored: true });
+  }
+}
+function collectInitializerSite(container, sites) {
+  const init = asRecord2(container?.init);
+  if (init === null) return;
+  sites.push({ container: init, key: "compiled", authored: true });
+}
+function stripDerivedBodies(member) {
+  return strippedClone("member", member);
+}
+function stripConstructorDerivedBodies(constructorRecord) {
+  return strippedClone("constructor", constructorRecord);
+}
+function stripMigrationAction(migration) {
+  return strippedClone("migration", migration);
+}
+function stampUILogicBody(logic, bodyKey) {
+  if (logic?.type !== 0 /* UI */) return false;
+  const body = asRecord2(logic[bodyKey]);
+  if (body === null) return false;
+  if (body.compilerRevision === NEOSCRIPT_COMPILER_REVISION) return false;
+  body.compilerRevision = NEOSCRIPT_COMPILER_REVISION;
+  return true;
+}
+function asRecord2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+var init_neo_script_derived_bodies = __esm({
+  "../src/database/neo-script-derived-bodies.ts"() {
+    "use strict";
+    init_members();
+    init_dialogue();
+    init_src();
+  }
+});
+
 // ../src/database/neo-script-recompile-scope.ts
 function memberNeoScriptContractChanged(current, next) {
   return canonicalJsonStringify(neoScriptMemberContractProjection(current)) !== canonicalJsonStringify(neoScriptMemberContractProjection(next));
@@ -84554,12 +84794,13 @@ function collectNeoScriptRecompileTargets(args) {
   };
   const memberIds = new Set(explicit.memberIds);
   for (const member of args.postDocument.members) {
-    if (recordDependsOnChangedContract(member, impactScope)) {
+    if (recordDependsOnChangedContract("member", member, impactScope)) {
       memberIds.add(member.id);
     }
   }
   const postValues = args.postDocument.values ?? [];
   const valueIds = selectedRecordIds(
+    "value",
     postValues,
     explicit.valueIds,
     impactScope
@@ -84587,22 +84828,26 @@ function collectNeoScriptRecompileTargets(args) {
     complete: false,
     memberIds,
     constructorIds: selectedRecordIds(
+      "constructor",
       args.postDocument.constructors ?? [],
       explicit.constructorIds,
       impactScope,
       (record4) => constructorOwnerById.get(record4.id) ?? null
     ),
     migrationIds: selectedRecordIds(
+      "migration",
       args.postDocument.migrations ?? [],
       explicit.migrationIds,
       impactScope
     ),
     dialogueNodeIds: selectedRecordIds(
+      "dialogue-node",
       args.postDocument.dialogueNodes ?? [],
       explicit.dialogueNodeIds,
       impactScope
     ),
     dialogueGroupIds: selectedRecordIds(
+      "dialogue-group",
       args.postDocument.dialogueGroups ?? [],
       explicit.dialogueGroupIds,
       impactScope
@@ -84984,17 +85229,17 @@ function explicitTargetIds(changes) {
   }
   return result;
 }
-function selectedRecordIds(records2, explicitIds, scope, ownerId = () => null) {
+function selectedRecordIds(recordKind, records2, explicitIds, scope, ownerId = () => null) {
   const selected = new Set(explicitIds);
   for (const record4 of records2) {
     const owner = ownerId(record4);
-    if (owner !== null && scope.impactedIds.has(owner) || recordDependsOnChangedContract(record4, scope)) {
+    if (owner !== null && scope.impactedIds.has(owner) || recordDependsOnChangedContract(recordKind, record4, scope)) {
       selected.add(record4.id);
     }
   }
   return selected;
 }
-function recordDependsOnChangedContract(record4, scope) {
+function recordDependsOnChangedContract(recordKind, record4, scope) {
   const recordId = isObjectRecord4(record4) ? record4.id : void 0;
   if (typeof recordId === "string" && scope.impactedIds.has(recordId)) {
     return true;
@@ -85008,6 +85253,7 @@ function recordDependsOnChangedContract(record4, scope) {
   if (intersects(collectConstructedClassIds(record4), scope.constructedClassIds)) {
     return true;
   }
+  if (hasPendingNeoScriptDerivation(recordKind, record4)) return true;
   if (scope.impactedIds.size === 0 && scope.impactedTypeNames.size === 0) {
     return false;
   }
@@ -85214,6 +85460,7 @@ var init_neo_script_recompile_scope = __esm({
   "../src/database/neo-script-recompile-scope.ts"() {
     "use strict";
     init_variant_value_graph();
+    init_neo_script_derived_bodies();
     init_canonical_json();
     init_src();
     init_member_kind_enum();
@@ -89452,6 +89699,7 @@ function stripTrailingSemicolon(value) {
 }
 function placeholderBoolGetter2() {
   return {
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION,
     parameters: [],
     typeInfo: { type: 1, required: true },
     instructions: [
@@ -89467,6 +89715,7 @@ function placeholderBoolGetter2() {
 }
 function placeholderVoidAction() {
   return {
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION,
     parameters: [],
     typeInfo: { type: 0, required: true },
     instructions: []
@@ -89474,6 +89723,7 @@ function placeholderVoidAction() {
 }
 function placeholderStringGetter() {
   return {
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION,
     parameters: [],
     typeInfo: { type: 3, required: true },
     instructions: [
@@ -97359,7 +97609,7 @@ var init_project_version_transaction_planning = __esm({
       delete: { documentsRead: 6, documentsWritten: 3, databaseQueries: 14 }
     };
     SCHEMA_CHANGE_COUNT_COSTS = {
-      create: { documentsRead: 3, documentsWritten: 5, databaseQueries: 12 },
+      create: { documentsRead: 9, documentsWritten: 7, databaseQueries: 9 },
       update: { documentsRead: 6, documentsWritten: 5, databaseQueries: 22 },
       delete: { documentsRead: 6, documentsWritten: 5, databaseQueries: 22 }
     };
@@ -97862,7 +98112,7 @@ function projectValueHeadPlacementGraph(args) {
     } : null;
     const storedMember = item.memberId === null ? void 0 : members.get(item.memberId);
     if (rootlessMember === null && storedMember === void 0) continue;
-    const member = rootlessMember ?? contextualMember(
+    const member = rootlessMember ?? item.constructorMember ?? contextualMember(
       resolvedMember(storedMember),
       item.bindings ?? emptyBindings
     );
@@ -97955,7 +98205,25 @@ function projectValueHeadPlacementGraph(args) {
     }
     for (const edge of constructorEdgesByOwner.get(item.valueId) ?? []) {
       const childMember = members.get(edge.memberId);
-      const childName = childMember === void 0 ? null : stringOrNull(resolvedMember(childMember).name);
+      let constructorMember;
+      if (edge.member !== void 0) {
+        if (!isRecord7(edge.member)) {
+          throw new Error(
+            `Constructor value edge for "${edge.targetValueId}" has a non-object member "${edge.memberId}".`
+          );
+        }
+        if (edge.member.id !== edge.memberId) {
+          throw new Error(
+            `Constructor value edge for "${edge.targetValueId}" has mismatched member "${edge.memberId}".`
+          );
+        }
+        constructorMember = edge.member;
+      }
+      let childName = null;
+      if (constructorMember !== void 0)
+        childName = stringOrNull(constructorMember.name);
+      else if (childMember !== void 0)
+        childName = stringOrNull(resolvedMember(childMember).name);
       queue.push({
         valueId: edge.targetValueId,
         memberId: edge.memberId,
@@ -97967,6 +98235,7 @@ function projectValueHeadPlacementGraph(args) {
         rootMemberId: item.rootMemberId,
         path: childName === null ? item.path : joinPath(item.path, childName),
         constructorOrigin: true,
+        constructorMember,
         bindings: childBindings,
         constructorParameterId: edge.parameterId,
         constructorSchemaKey: edge.schemaKey
@@ -99047,7 +99316,10 @@ function recompileDialogueNode(args) {
       const action = asObject(actionValue2);
       if (action?.type !== 0 /* EditMember */) continue;
       const logic = asObject(action.logic);
-      if (!isCodeLogic(logic)) continue;
+      if (!isCodeLogic(logic)) {
+        changed = stampUILogicBody(logic, "action") || changed;
+        continue;
+      }
       const compiled = compileSourceUnit(
         args.sourceLabel,
         () => compileDialogueLogicWithProjectData(
@@ -99132,7 +99404,10 @@ function recompileConditionList(value, context) {
   let changed = false;
   for (const conditionValue of value) {
     const condition = asObject(conditionValue);
-    if (!isCodeLogic(condition)) continue;
+    if (!isCodeLogic(condition)) {
+      changed = stampUILogicBody(condition, "getter") || changed;
+      continue;
+    }
     const compiled = compileSourceUnit(
       context.sourceLabel,
       () => compileDialogueLogicWithProjectData(
@@ -99239,6 +99514,7 @@ function compileSourceUnit(label, compile, onSourceRejection, compileErrorFallba
 }
 function makeThrowBody(message, typeInfo) {
   return {
+    compilerRevision: NEOSCRIPT_COMPILER_REVISION,
     parameters: [],
     instructions: [
       {
@@ -99291,6 +99567,8 @@ var init_general_function_call_ir_source_recompile = __esm({
     init_compiler_adapter();
     init_neoscript();
     init_dialogue_node_index();
+    init_src();
+    init_neo_script_derived_bodies();
     VOID_ACTION_TYPE_INFO = {
       type: 0 /* Null */,
       required: true
@@ -99306,6 +99584,77 @@ var init_general_function_call_ir_source_recompile = __esm({
   }
 });
 
+// ../src/database/project-record-semantics.ts
+function projectRecordSemanticData(value) {
+  if (!isPlainRecord(value)) return value;
+  const semantic = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (SERVER_MANAGED_PROJECT_RECORD_FIELDS.has(key)) continue;
+    semantic[key] = child;
+  }
+  return semantic;
+}
+function projectRecordDataIsSemanticallyEqual(left, right) {
+  return canonicalJsonStringify2(projectRecordSemanticData(left)) === canonicalJsonStringify2(projectRecordSemanticData(right));
+}
+function canonicalJsonStringify2(value) {
+  return JSON.stringify(toCanonicalJsonValue2(value));
+}
+function toCanonicalJsonValue2(value) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Cannot canonicalize a non-finite number.");
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    throw new Error("Cannot canonicalize bigint values.");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot canonicalize symbol values.");
+  }
+  if (typeof value === "function") {
+    throw new Error("Cannot canonicalize function values.");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toCanonicalJsonValue2(item) ?? null);
+  }
+  if (!isPlainRecord(value)) {
+    throw new Error("Cannot canonicalize a non-plain object.");
+  }
+  const canonical = {};
+  const entries = Object.entries(value).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  for (const [key, child] of entries) {
+    const canonicalChild = toCanonicalJsonValue2(child);
+    if (canonicalChild === void 0) continue;
+    canonical[key] = canonicalChild;
+  }
+  return canonical;
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var SERVER_MANAGED_PROJECT_RECORD_FIELDS;
+var init_project_record_semantics = __esm({
+  "../src/database/project-record-semantics.ts"() {
+    "use strict";
+    SERVER_MANAGED_PROJECT_RECORD_FIELDS = /* @__PURE__ */ new Set([
+      "_id",
+      "projectId",
+      "createdAt",
+      "updatedAt"
+    ]);
+  }
+});
+
 // ../src/database/project-version-relation-sweep-trigger.ts
 function stagedChangesAffectClassRelations(current, changes) {
   const classesById = new Map(
@@ -99322,7 +99671,7 @@ function stagedChangesAffectClassRelations(current, changes) {
       const before2 = classesById.get(change.recordId);
       if (before2 === void 0) return true;
       const after = change.nextData;
-      if (!isPlainRecord(after)) return true;
+      if (!isPlainRecord2(after)) return true;
       if (before2.extendsClassId !== after.extendsClassId) return true;
       continue;
     }
@@ -99341,17 +99690,20 @@ function valueCreateCannotAffectClassRelations(change, before) {
   return before === void 0;
 }
 function relationEndpointClassId(record4) {
-  if (!isPlainRecord(record4)) return void 0;
+  if (!isPlainRecord2(record4)) return void 0;
   if (typeof record4.classId === "string") return record4.classId;
   return void 0;
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   if (value === null || typeof value !== "object") return false;
   return !Array.isArray(value);
 }
 var init_project_version_relation_sweep_trigger = __esm({
   "../src/database/project-version-relation-sweep-trigger.ts"() {
     "use strict";
+    init_internal_record_relations();
+    init_project_version_types();
+    init_project_record_semantics();
   }
 });
 
@@ -100670,7 +101022,513 @@ var init_member_localization_normalization = __esm({
   }
 });
 
+// ../src/database/owned-value-deletion.ts
+function collectOwnedValueDeletionIds(args) {
+  if (args.rootIds.length === 0) return [];
+  return createOwnedValueDeletionCollector(
+    args.document,
+    args.placements
+  ).collect(args);
+}
+function createOwnedValueDeletionCollector(input, knownPlacements) {
+  const scope = withVariantPlacementRoots(input);
+  const document = scope.document;
+  const stored = new Map(document.values.map((row) => [row.id, row]));
+  const members = new Map(
+    document.members.map((member) => [member.id, member])
+  );
+  const placements = knownPlacements === void 0 ? findSemanticOwnerPlacementsForValues(
+    scope.document,
+    new Set(stored.keys()),
+    scope.roots
+  ) : new Map(knownPlacements);
+  let graph;
+  const childrenByContainer = /* @__PURE__ */ new Map();
+  for (const row of document.values) {
+    if (typeof row.containerId !== "string") continue;
+    const children = childrenByContainer.get(row.containerId) ?? /* @__PURE__ */ new Set();
+    children.add(row.id);
+    childrenByContainer.set(row.containerId, children);
+  }
+  const schemas = /* @__PURE__ */ new Map();
+  const schemaFor = (classId) => {
+    let schema = schemas.get(classId);
+    if (schema === void 0) {
+      schema = mergeStoredInstanceSchema(
+        classId,
+        document.classes,
+        document.members
+      );
+      schemas.set(classId, schema);
+    }
+    return schema;
+  };
+  const expanded = /* @__PURE__ */ new Map();
+  let lookups;
+  const classMember = (classId) => ({
+    name: "Deletion root",
+    kind: 7 /* Class */,
+    classId
+  });
+  const currentDocument = () => ({ ...document, values: [...stored.values()] });
+  let constructorTypes;
+  let independentlyOwnedBeforeAppend;
+  const constructorEdgesFor = (row) => {
+    if (!isLiteralValueContent(row) || !Object.values(row.constructorArgs ?? {}).some(
+      (value) => typeof value === "string"
+    ))
+      return [];
+    constructorTypes ??= new MaterializedValueGraphContext(
+      { ...document, values: [] },
+      /* @__PURE__ */ new Map(),
+      new Map(
+        scope.roots.flatMap(
+          (root) => isMemberClassBase(root.member) ? [[root.valueId, root.member]] : []
+        )
+      )
+    );
+    return constructorTypes.constructorEdges(row);
+  };
+  const appendDisjointRows = (rows) => {
+    if (rows.length === 0) return true;
+    const addedIds = new Set(rows.map((row) => row.id));
+    const referencedIds2 = /* @__PURE__ */ new Set();
+    const referencesStored = (value) => {
+      if (typeof value === "string") {
+        if (addedIds.has(value)) referencedIds2.add(value);
+        return stored.has(value);
+      }
+      if (value === null || typeof value !== "object") return false;
+      return Object.values(value).some(referencesStored);
+    };
+    const deltaRows = new Map(rows.map((row) => [row.id, row]));
+    const roots = [];
+    for (const row of rows) {
+      if (stored.has(row.id) || !isLiteralValueContent(row)) return false;
+      const argumentEdges = constructorEdgesFor(row);
+      if (argumentEdges.length > 0) {
+        if (independentlyOwnedBeforeAppend === void 0) {
+          graph ??= createVariantMaterializedValueGraphContext(
+            currentDocument(),
+            document.variants ?? []
+          );
+          independentlyOwnedBeforeAppend = graph.independentlyOwnedValueIds;
+        }
+        if (argumentEdges.some(
+          (edge) => !independentlyOwnedBeforeAppend.has(edge.targetValueId)
+        ))
+          return false;
+      }
+      if (referencesStored(row.value)) return false;
+      if (typeof row.containerId !== "string") continue;
+      if (addedIds.has(row.containerId)) {
+        referencedIds2.add(row.id);
+        continue;
+      }
+      const parent = stored.get(row.containerId);
+      const placement = placements.get(row.containerId);
+      if (parent === void 0 || placement === void 0) return false;
+      deltaRows.set(parent.id, parent);
+      roots.push({
+        valueId: parent.id,
+        member: placement.member,
+        position: placement.position
+      });
+      referencedIds2.add(row.id);
+    }
+    for (const row of rows) {
+      if (referencedIds2.has(row.id) || typeof row.classId !== "string")
+        continue;
+      roots.push({
+        valueId: row.id,
+        member: classMember(row.classId),
+        position: { insideAnimationOverrideGraph: false }
+      });
+    }
+    const deltaPlacements = findSemanticOwnerPlacementsForValues(
+      { ...document, values: [...deltaRows.values()] },
+      addedIds,
+      roots
+    );
+    for (const [id2, placement] of deltaPlacements)
+      placements.set(id2, placement);
+    for (const row of rows) {
+      stored.set(row.id, row);
+      if (typeof row.containerId !== "string") continue;
+      const children = childrenByContainer.get(row.containerId) ?? /* @__PURE__ */ new Set();
+      children.add(row.id);
+      childrenByContainer.set(row.containerId, children);
+    }
+    graph = void 0;
+    lookups = void 0;
+    expanded.clear();
+    return true;
+  };
+  const collect = (args) => {
+    const roots = new Set(args.rootIds);
+    const resolve5 = (id2, member) => {
+      if (args.resolveValueById !== void 0)
+        return args.resolveValueById(id2) ?? stored.get(id2);
+      const cached = expanded.get(id2);
+      if (cached !== void 0) return cached;
+      const row = stored.get(id2);
+      if (row !== void 0 && member !== void 0) {
+        if (!isMemberClassBase(member) && !isMemberListBase(member) && !isMemberDictionaryBase(member))
+          return row;
+        if (isLiteralValueContent(row) && (isMemberListBase(member) && member.listKind !== 1 /* Unordered */ && Array.isArray(row.value) || isMemberDictionaryBase(member) && row.value !== null && typeof row.value === "object" && !Array.isArray(row.value)) && [...storedValueChildReferences({ member, body: row.value })].every(
+          (child) => stored.has(child.valueId)
+        ))
+          return row;
+        if (isMemberClassBase(member) && isLiteralValueContent(row) && row.value !== null && typeof row.value === "object" && !Array.isArray(row.value)) {
+          const body = row.value;
+          const complete2 = schemaFor(row.classId ?? member.classId).every(
+            (field) => {
+              if (field.memberId === null) return true;
+              const childMember = members.get(field.memberId);
+              if (childMember === void 0) return false;
+              if (!memberKindOwnsStoredValue(childMember.kind)) return true;
+              const childId = body[field.schemaKey];
+              return childId === null || typeof childId === "string" && stored.has(childId);
+            }
+          );
+          if (complete2) return row;
+        }
+      }
+      if (row !== void 0 && isLiteralValueContent(row) && (isVirtualInstanceRootShape(row) || typeof row.value === "object")) {
+        lookups ??= initializerEvaluatorLookups(currentDocument());
+        for (const value of lookups.virtualInstanceRowsForValue(id2)) {
+          expanded.set(value.id, value);
+          if (typeof value.containerId === "string") {
+            const children = childrenByContainer.get(value.containerId) ?? /* @__PURE__ */ new Set();
+            children.add(value.id);
+            childrenByContainer.set(value.containerId, children);
+          }
+        }
+        return expanded.get(id2) ?? row;
+      }
+      return row;
+    };
+    const deleted = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const pending = args.rootIds.map((id2) => ({
+      id: id2,
+      member: args.rootMembers?.get(id2) ?? placements.get(id2)?.member
+    }));
+    while (pending.length > 0) {
+      const item = pending.pop();
+      if (visited.has(item.id)) continue;
+      if (args.preservedValueIds?.has(item.id)) continue;
+      const placement = placements.get(item.id);
+      if (!roots.has(item.id) && placement !== void 0 && placement.parentValueId !== item.parentId && stored.get(item.id)?.containerId !== item.parentId)
+        continue;
+      visited.add(item.id);
+      const durable = stored.get(item.id);
+      const declaredMember = item.member ?? placement?.member ?? (typeof durable?.classId === "string" ? classMember(durable.classId) : void 0);
+      const resolved = resolve5(item.id, declaredMember);
+      if (durable === void 0 && resolved === void 0) continue;
+      if (durable !== void 0) deleted.add(item.id);
+      const row = resolved ?? durable;
+      const member = declaredMember ?? (typeof row.classId === "string" ? classMember(row.classId) : void 0);
+      if (member === void 0) {
+        if (roots.has(item.id)) continue;
+        if (Array.isArray(row.value))
+          throw new Error(
+            `Cannot delete value "${item.id}" descendants without its collection member.`
+          );
+        if (row.value !== null && typeof row.value === "object") {
+          throw new Error(
+            `Cannot determine ownership of object value "${item.id}" without its member.`
+          );
+        }
+        continue;
+      }
+      if (durable !== void 0 && constructorEdgesFor(durable).some(
+        (edge) => !independentlyOwnedBeforeAppend?.has(edge.targetValueId)
+      )) {
+        graph ??= createVariantMaterializedValueGraphContext(
+          currentDocument(),
+          document.variants ?? []
+        );
+        for (const ownedId of graph.collectSoftOwnedRows(
+          item.id,
+          args.preservedValueIds
+        )) {
+          if (stored.has(ownedId)) deleted.add(ownedId);
+        }
+      }
+      if (!isMemberClassBase(member) && !isMemberListBase(member) && !isMemberDictionaryBase(member))
+        continue;
+      const bodies = durable === void 0 || durable === row ? [row] : [durable, row];
+      for (const body of bodies) {
+        if (!isLiteralValueContent(body)) continue;
+        let env = envFromStamp(body.genericBindings);
+        let classFields;
+        if (isMemberClassBase(member)) {
+          const classId = body.classId ?? member.classId;
+          env = new Map([
+            ...resolveInstanceEnv(
+              classId,
+              member.classArguments,
+              document.classes
+            ),
+            ...env
+          ]);
+          classFields = schemaFor(classId).flatMap(
+            (field) => field.memberId === null ? [] : [{ schemaKey: field.schemaKey, memberId: field.memberId }]
+          );
+          if (body.value !== null && typeof body.value === "object" && !Array.isArray(body.value)) {
+            const record4 = body.value;
+            const sidecars = consumeWorldPlacementSidecarKeys({
+              body: record4,
+              classes: document.classes,
+              classId,
+              label: `Value "${body.id}"`
+            });
+            for (const key of ["assetValueId", "layerOverrideValueId"]) {
+              if (key === "assetValueId" && !sidecars.has(key)) continue;
+              if (key === "layerOverrideValueId") {
+                const worldKind = resolveWorldSystemClassKind(
+                  classId,
+                  document.classes
+                );
+                if (worldKind !== NeoWorldSystemClassKind.TileLayerLink && worldKind !== NeoWorldSystemClassKind.ObjectLayerLink)
+                  continue;
+              }
+              const id2 = record4[key];
+              if (typeof id2 !== "string") continue;
+              const child = stored.get(id2);
+              if (child?.containerId !== body.id)
+                throw new Error(
+                  `Value "${body.id}" sidecar "${key}" does not own "${id2}".`
+                );
+              pending.push({ id: id2, parentId: body.id });
+            }
+          }
+        }
+        for (const child of storedValueChildReferences({
+          member,
+          body: body.value,
+          classFields,
+          unorderedValueIds: isMemberListBase(member) && member.listKind === 1 /* Unordered */ ? [
+            .../* @__PURE__ */ new Set([
+              ...childrenByContainer.get(body.id) ?? [],
+              ...args.unorderedListEntryIds?.(body.id) ?? []
+            ])
+          ] : void 0
+        })) {
+          const declared = members.get(child.memberId);
+          if (declared === void 0)
+            throw new Error(
+              `Value "${body.id}" child "${child.valueId}" has missing member "${child.memberId}".`
+            );
+          const childMember = substituteMember(declared, env, document.members);
+          pending.push({
+            id: child.valueId,
+            member: childMember,
+            parentId: body.id
+          });
+        }
+      }
+    }
+    return [...deleted];
+  };
+  return { collect, appendDisjointRows };
+}
+var init_owned_value_deletion = __esm({
+  "../src/database/owned-value-deletion.ts"() {
+    "use strict";
+    init_classes();
+    init_core();
+    init_members();
+    init_generics();
+    init_inheritance();
+    init_stored_value_shape();
+    init_instance_provenance();
+    init_evaluateInitializer();
+    init_variant_value_graph();
+    init_constructor_argument_ownership();
+    init_world_content_sidecar_validation();
+  }
+});
+
 // ../src/database/project-version-schema-commit.ts
+function memberDefaultOwnedRootIds(document, member) {
+  if (member.defaultValue == null) return [];
+  const resolved = resolveMember2(member, document.members);
+  let classFields;
+  if (isMemberClassBase(resolved)) {
+    const classId = member.defaultValue.classId ?? resolved.classId;
+    classFields = mergeStoredInstanceSchema(
+      classId,
+      document.classes,
+      document.members
+    ).flatMap(
+      (entry) => entry.memberId === null ? [] : [{ schemaKey: entry.schemaKey, memberId: entry.memberId }]
+    );
+  }
+  return [
+    ...storedValueChildReferences({
+      member: resolved,
+      body: member.defaultValue.value,
+      classFields
+    })
+  ].map((reference2) => reference2.valueId);
+}
+function appendAuthoredOwnedValueCascadeDeletes(args) {
+  const roots = /* @__PURE__ */ new Set();
+  const membersById = indexRecordsById(args.document.members);
+  const variantsById = indexRecordsById(args.document.variants ?? []);
+  for (const change of args.authoredChanges) {
+    if (change.operation !== "delete") continue;
+    if (change.recordKind === "value") {
+      roots.add(change.recordId);
+      continue;
+    }
+    if (change.recordKind === "variant") {
+      const variantRootId = variantsById.get(change.recordId)?.valueId;
+      if (typeof variantRootId === "string") roots.add(variantRootId);
+      continue;
+    }
+    if (change.recordKind !== "member") continue;
+    const member = membersById.get(change.recordId);
+    if (member === void 0) continue;
+    if (typeof member.valueId === "string") roots.add(member.valueId);
+    for (const valueId of memberDefaultOwnedRootIds(args.document, member)) {
+      roots.add(valueId);
+    }
+  }
+  for (const change of args.authoredChanges) {
+    if (change.recordKind !== "member" || change.operation !== "update") {
+      continue;
+    }
+    const current = membersById.get(change.recordId);
+    if (current === void 0) continue;
+    const next = change.nextData;
+    if (current.valueId === next.valueId && canonicallyEqual2(current.defaultValue, next.defaultValue)) {
+      continue;
+    }
+    const serverHandlesStoredToReadOnly = args.expandReadOnlySourceConversions && isAbstractMember(current) !== true && isAbstractMember(next) !== true && isReadOnlyMember(current) !== true && isReadOnlyMember(next) === true;
+    if (!serverHandlesStoredToReadOnly && typeof current.valueId === "string" && current.valueId !== next.valueId) {
+      roots.add(current.valueId);
+    }
+    for (const valueId of memberDefaultOwnedRootIds(args.document, current)) {
+      roots.add(valueId);
+    }
+  }
+  if (roots.size === 0) return;
+  const authoredPost = applyProjectVersionWriteChanges(
+    args.document,
+    args.authoredChanges
+  );
+  const postScope = withVariantPlacementRoots(authoredPost);
+  const postValueIds = new Set(authoredPost.values.map((value) => value.id));
+  const postPlacements = findSemanticOwnerPlacementsForValues(
+    postScope.document,
+    postValueIds,
+    postScope.roots
+  );
+  const preservedValueIds = new Set(postPlacements.keys());
+  const preScope = withVariantPlacementRoots(args.document);
+  const prePlacements = findSemanticOwnerPlacementsForValues(
+    preScope.document,
+    new Set(args.document.values.map((value) => value.id)),
+    preScope.roots,
+    true
+  );
+  const postValuesById = indexRecordsById(authoredPost.values);
+  const survivingConstructionIds = /* @__PURE__ */ new Set();
+  for (const rootId of roots) {
+    let parentId = prePlacements.get(rootId)?.parentValueId;
+    const visited = /* @__PURE__ */ new Set();
+    while (parentId != null && !visited.has(parentId)) {
+      visited.add(parentId);
+      const parent = postValuesById.get(parentId);
+      if (parent !== void 0 && isLiteralValueContent(parent) && isVirtualInstanceRootShape(parent) && postPlacements.has(parentId)) {
+        survivingConstructionIds.add(parentId);
+        break;
+      }
+      parentId = prePlacements.get(parentId)?.parentValueId;
+    }
+  }
+  if (survivingConstructionIds.size > 0) {
+    const resolverDocument = composeResolverDocument(
+      postScope.document,
+      initializerEvaluatorLookups(postScope.document)
+    );
+    const materializedIndex = buildVirtualInstanceMaterializedIndex({
+      document: resolverDocument
+    });
+    for (const rootId of survivingConstructionIds) {
+      const instanceRoot = postValuesById.get(rootId);
+      const rootMember = postPlacements.get(rootId).member;
+      const expanded = expandStoredInstance({
+        document: resolverDocument,
+        instanceRoot,
+        rootMember,
+        evaluateInitializer: evaluateMemberInitializer
+      });
+      const graph = resolveVirtualInstanceGraph({
+        document: resolverDocument,
+        instanceRoot,
+        rootMember,
+        expandedRoot: expanded.root,
+        expandedRows: expanded.rows,
+        pinnedRootSchemaKeys: expanded.pinnedRootSchemaKeys,
+        materializedIndex
+      });
+      for (const id2 of graph.rowsById.keys()) {
+        if (postValueIds.has(id2)) preservedValueIds.add(id2);
+      }
+    }
+  }
+  const cascadeIds = collectOwnedValueDeletionIds({
+    document: args.document,
+    placements: prePlacements,
+    rootIds: [...roots],
+    preservedValueIds
+  });
+  const existingByValueId = /* @__PURE__ */ new Map();
+  for (const change of args.authoredChanges) {
+    if (change.recordKind === "value") {
+      existingByValueId.set(change.recordId, change);
+    }
+  }
+  const baseHashByValueId = indexLiveContentHashesByRecordId(
+    args.contentHashHeads,
+    "value"
+  );
+  const appendedDeleteIds = /* @__PURE__ */ new Set();
+  for (const valueId of cascadeIds) {
+    const existing = existingByValueId.get(valueId);
+    if (existing?.operation === "delete") continue;
+    if (existing !== void 0) {
+      throw new Error(
+        `Authored value "${valueId}" is updated while its owning value graph is deleted. Reparent it from a surviving member or value in the same commit.`
+      );
+    }
+    const expectedBaseContentHash = baseHashByValueId.get(valueId);
+    if (expectedBaseContentHash === void 0) continue;
+    const change = {
+      recordKind: "value",
+      recordId: valueId,
+      operation: "delete",
+      deleted: true,
+      expectedBaseContentHash,
+      intent: createProjectVersionIntent("value.delete", {
+        source: "server-owned-value-cascade"
+      })
+    };
+    args.authoredChanges.push(change);
+    appendedDeleteIds.add(valueId);
+    existingByValueId.set(valueId, change);
+  }
+  return appendedDeleteIds.size === 0 ? authoredPost : {
+    ...authoredPost,
+    values: authoredPost.values.filter(
+      (value) => !appendedDeleteIds.has(value.id)
+    )
+  };
+}
 function indexRecordsById(records2) {
   const recordsById2 = /* @__PURE__ */ new Map();
   for (const record4 of records2) recordsById2.set(record4.id, record4);
@@ -100781,10 +101639,12 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
       authoredChanges
     );
   }
-  let authoredPost = applyProjectVersionWriteChanges(
-    args.document,
-    authoredChanges
-  );
+  let authoredPost = appendAuthoredOwnedValueCascadeDeletes({
+    document: args.document,
+    authoredChanges,
+    contentHashHeads: args.contentHashHeads,
+    expandReadOnlySourceConversions: args.expandReadOnlySourceConversions === true
+  }) ?? applyProjectVersionWriteChanges(args.document, authoredChanges);
   if (authoredPost.localizationConfig?.mainLocale !== args.document.localizationConfig?.mainLocale) {
     const normalized = planMemberLocalizationNormalization(
       authoredPost,
@@ -101184,11 +102044,6 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     prepared,
     contentHashHeads: args.contentHashHeads
   });
-  appendVariantGraphCascadeDeletes({
-    document: args.document,
-    prepared,
-    contentHashHeads: args.contentHashHeads
-  });
   let localizationChanges = reconcileGeneratedLocalizedTextCreates(
     args.document,
     prepared
@@ -101344,7 +102199,8 @@ function attachPreparedValuePlacements(prepared, document) {
         targetValueId: edge.targetValueId,
         memberId: owner.memberId,
         parameterId: edge.parameterId,
-        schemaKey: owner.schemaKey
+        schemaKey: owner.schemaKey,
+        member: owner.member
       });
     }
   }
@@ -101386,8 +102242,8 @@ function attachPreparedConstructorAggregateEdges(prepared, document) {
   );
   if (valueChanges.length === 0) return;
   const needsGraph = valueChanges.some((change) => {
-    const constructorArgs = asRecord2(
-      asRecord2(change.nextData)?.constructorArgs
+    const constructorArgs = asRecord3(
+      asRecord3(change.nextData)?.constructorArgs
     );
     return constructorArgs !== null && Object.keys(constructorArgs).length > 0;
   });
@@ -101791,7 +102647,7 @@ function localizedTextCreateEnvelopeConfig(args) {
     (change) => change.recordKind === "localization-config"
   );
   if (configChange?.operation === "delete") return null;
-  const candidate = asRecord2(
+  const candidate = asRecord3(
     configChange?.nextData ?? args.document.localizationConfig
   );
   if (candidate === null) return null;
@@ -102058,7 +102914,7 @@ function removeDirectBindingsFromReadOnlySourceTransitions(currentDocument, chan
       continue;
     }
     const current = currentMembers.get(change.recordId);
-    const next = asRecord2(change.nextData);
+    const next = asRecord3(change.nextData);
     if (current === void 0 || next === null) continue;
     if (isAbstractMember(current) || isAbstractMember(next)) continue;
     if (isReadOnlyMember(current) || !isReadOnlyMember(next)) continue;
@@ -102177,7 +103033,7 @@ function prepareServerOwnedDialogueBodies(args) {
     }
     if (change.recordKind === "dialogue-node") {
       explicitNodeIds.add(change.recordId);
-      const next = asRecord2(change.nextData);
+      const next = asRecord3(change.nextData);
       const current = currentNodes.get(change.recordId);
       if (typeof current?.dialogueId === "string") {
         changedDialogueIds.add(current.dialogueId);
@@ -103907,7 +104763,7 @@ function delegateValueRow(value) {
 }
 function inlineDelegateArgumentRow(value) {
   if (!isMemberValue(value) || !isLiteralValueContent(value)) return null;
-  const constructorArgs = asRecord2(
+  const constructorArgs = asRecord3(
     value.constructorArgs
   );
   if (constructorArgs === null) return null;
@@ -103919,14 +104775,14 @@ function inlineDelegateArgumentRow(value) {
   return null;
 }
 function isUncompiledInlineDelegateArgument(argument2) {
-  const closure = asRecord2(argument2);
+  const closure = asRecord3(argument2);
   if (closure === null) return false;
   if (typeof closure.code !== "string") return false;
   return !("action" in closure);
 }
 function compileInlineDelegateConstructorArguments(args) {
   const { document, row, ownerMember, rootOwner } = args;
-  const constructorArgs = asRecord2(row.constructorArgs);
+  const constructorArgs = asRecord3(row.constructorArgs);
   if (constructorArgs === null) {
     throw new Error(
       `Value "${row.id}" was collected for inline delegate compilation without constructor arguments.`
@@ -103961,7 +104817,7 @@ function compileInlineDelegateConstructorArguments(args) {
       `Value "${row.id}" inline delegate compilation cannot find constructor "${constructorId ?? "none"}" on class "${schemaClass2.name}".`
     );
   }
-  const ownerClassArguments = asRecord2(
+  const ownerClassArguments = asRecord3(
     ownerMember?.classArguments
   );
   const env = resolveInstanceEnv(
@@ -104402,7 +105258,7 @@ function assertUniqueChanges(changes) {
     }
     keys.add(key);
     if (change.operation !== "delete") {
-      const nextData = asRecord2(change.nextData);
+      const nextData = asRecord3(change.nextData);
       if (nextData === null) {
         throw new Error(`Schema commit change "${key}" requires nextData.`);
       }
@@ -104414,190 +105270,6 @@ function assertUniqueChanges(changes) {
     }
   }
 }
-function cloneAndStripClientDerivedBodies(change) {
-  if (change.operation === "delete" || change.nextData === void 0) {
-    return { ...change };
-  }
-  if (change.recordKind === "migration") {
-    const nextData2 = asRecord2(change.nextData);
-    return {
-      ...change,
-      nextData: nextData2 === null ? change.nextData : stripMigrationAction(nextData2)
-    };
-  }
-  if (change.recordKind === "dialogue-node") {
-    const nextData2 = asRecord2(change.nextData);
-    return {
-      ...change,
-      nextData: nextData2 === null ? change.nextData : stripDialogueNodeDerivedBodies(nextData2)
-    };
-  }
-  if (change.recordKind === "dialogue-group") {
-    const nextData2 = asRecord2(change.nextData);
-    return {
-      ...change,
-      nextData: nextData2 === null ? change.nextData : stripDialogueGroupDerivedBodies(nextData2)
-    };
-  }
-  if (change.recordKind === "constructor") {
-    const nextData2 = asRecord2(change.nextData);
-    return {
-      ...change,
-      nextData: nextData2 === null ? change.nextData : stripConstructorDerivedBodies(nextData2)
-    };
-  }
-  if (change.recordKind === "value") {
-    const nextData2 = asRecord2(change.nextData);
-    if (nextData2 === null) return { ...change, nextData: change.nextData };
-    const stripped = { ...nextData2 };
-    stripInitializerCompanion(stripped, "init");
-    stripDelegateClosureCompanion(stripped, "value");
-    stripInlineDelegateArgumentCompanions(stripped);
-    return { ...change, nextData: stripped };
-  }
-  if (change.recordKind !== "member") {
-    return { ...change, nextData: change.nextData };
-  }
-  const nextData = asRecord2(change.nextData);
-  if (nextData === null) return { ...change, nextData: change.nextData };
-  return {
-    ...change,
-    nextData: stripDerivedBodies(nextData)
-  };
-}
-function stripDialogueNodeDerivedBodies(node) {
-  const next = structuredClone(node);
-  stripConditionCompanions(next.conditions);
-  stripTextVariableCompanions(next.variables);
-  if (Array.isArray(next.actions)) {
-    for (const actionValue2 of next.actions) {
-      const action = asRecord2(actionValue2);
-      const logic = asRecord2(action?.logic);
-      if (logic?.type === 1 && typeof logic.code === "string") {
-        delete logic.action;
-      }
-    }
-  }
-  if (Array.isArray(next.outcomes)) {
-    for (const outcomeValue of next.outcomes) {
-      const outcome = asRecord2(outcomeValue);
-      if (outcome !== null) stripConditionCompanions(outcome.conditions);
-    }
-  }
-  const optionSettings = asRecord2(next.optionSettings);
-  if (Array.isArray(optionSettings?.options)) {
-    for (const optionValue of optionSettings.options) {
-      const option = asRecord2(optionValue);
-      if (option === null) continue;
-      stripTextVariableCompanions(option.variables);
-      const settings = asRecord2(option.settings);
-      if (settings === null) continue;
-      stripConditionCompanions(settings.conditions);
-      stripConditionCompanions(settings.selectableConditions);
-    }
-  }
-  return next;
-}
-function stripDialogueGroupDerivedBodies(group) {
-  const next = structuredClone(group);
-  stripConditionCompanions(next.conditions);
-  return next;
-}
-function stripConditionCompanions(value) {
-  if (!Array.isArray(value)) return;
-  for (const conditionValue of value) {
-    const condition = asRecord2(conditionValue);
-    if (condition?.type === 1 && typeof condition.code === "string") {
-      delete condition.getter;
-    }
-  }
-}
-function stripTextVariableCompanions(value) {
-  const variables = asRecord2(value);
-  if (variables === null) return;
-  for (const variableValue of Object.values(variables)) {
-    const variable2 = asRecord2(variableValue);
-    if (variable2 !== null && typeof variable2.code === "string") {
-      delete variable2.getter;
-    }
-  }
-}
-function stripDerivedBodies(member) {
-  const next = { ...member };
-  if (member.kind === 10 /* NSProperty */) {
-    delete next.getter;
-    delete next.setter;
-  }
-  if (member.kind === 23 /* NSFunction */) {
-    delete next.action;
-  }
-  if (member.kind === 25 /* NSDelegate */) {
-    stripDelegateClosureCompanion(next, "defaultValue");
-  }
-  stripInitializerCompanion(next, "defaultValue");
-  return next;
-}
-function stripInlineDelegateArgumentCompanions(record4) {
-  const constructorArgs = asRecord2(record4.constructorArgs);
-  if (constructorArgs === null) return;
-  let changed = false;
-  const stripped = { ...constructorArgs };
-  for (const [key, argument2] of Object.entries(constructorArgs)) {
-    const closure = asRecord2(argument2);
-    if (closure === null) continue;
-    if (typeof closure.code !== "string") continue;
-    if (!("action" in closure)) continue;
-    const authored = { ...closure };
-    delete authored.action;
-    stripped[key] = authored;
-    changed = true;
-  }
-  if (changed) record4.constructorArgs = stripped;
-}
-function stripDelegateClosureCompanion(record4, field) {
-  const container = field === "value" ? record4 : asRecord2(record4.defaultValue);
-  if (container === null) return;
-  const delegate = asRecord2(container.value);
-  if (delegate === null || typeof delegate.code !== "string") return;
-  if (!("action" in delegate)) return;
-  const authoredDelegate = { ...delegate };
-  delete authoredDelegate.action;
-  if (field === "value") {
-    record4.value = authoredDelegate;
-    return;
-  }
-  record4.defaultValue = { ...container, value: authoredDelegate };
-}
-function stripInitializerCompanion(record4, field) {
-  const container = field === "init" ? record4 : asRecord2(record4.defaultValue);
-  if (container === null) return;
-  const init = asRecord2(container.init);
-  if (init === null) return;
-  const authoredInit = { ...init };
-  delete authoredInit.compiled;
-  if (field === "init") {
-    record4.init = authoredInit;
-    return;
-  }
-  record4.defaultValue = { ...container, init: authoredInit };
-}
-function stripConstructorDerivedBodies(constructorRecord) {
-  const {
-    action: _action,
-    compiledBaseArguments: _compiledBaseArguments,
-    compiledBaseInitializerFields: _compiledBaseInitializerFields,
-    ...next
-  } = constructorRecord;
-  void _action;
-  void _compiledBaseArguments;
-  void _compiledBaseInitializerFields;
-  return next;
-}
-function stripMigrationAction(migration) {
-  const { action: _action, ...next } = migration;
-  void _action;
-  return next;
-}
 function applyProjectVersionWriteChanges(document, changes) {
   return projectVersionDocumentWithChanges(document, changes, false);
 }
@@ -104705,7 +105377,7 @@ function applyArrayChanges(current, changes) {
   }
   return [...byId.values()];
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return null;
   }
@@ -104869,52 +105541,12 @@ function variantConstructorArgumentIsRestValue(schemaKey, value) {
   }
   return schemaKey === NEO_VARIANT_CHILD_OVERRIDES_SCHEMA_KEY && Array.isArray(value) && value.length === 0;
 }
-function appendVariantGraphCascadeDeletes(args) {
-  const deletedVariantIds = /* @__PURE__ */ new Set();
-  for (const change of args.prepared) {
-    if (change.recordKind !== "variant") continue;
-    if (change.operation !== "delete") continue;
-    deletedVariantIds.add(change.recordId);
-  }
-  if (deletedVariantIds.size === 0) return;
-  const valueIds = collectVariantGraphValueIds({
-    document: args.document,
-    variants: args.document.variants ?? [],
-    variantIds: deletedVariantIds
-  });
-  const alreadyChanged = /* @__PURE__ */ new Set();
-  for (const change of args.prepared) {
-    if (change.recordKind === "value") alreadyChanged.add(change.recordId);
-  }
-  const baseHashByValueId = indexLiveContentHashesByRecordId(
-    args.contentHashHeads,
-    "value"
-  );
-  for (const valueId of valueIds) {
-    if (alreadyChanged.has(valueId)) continue;
-    const baseContentHash = baseHashByValueId.get(valueId);
-    if (baseContentHash === void 0) continue;
-    args.prepared.push({
-      recordKind: "value",
-      recordId: valueId,
-      operation: "delete",
-      // The commit boundary keys tombstones on `deleted`, not on `operation`:
-      // without it the change reads as an update carrying no nextData and the
-      // whole push is rejected. The editor spells its own graph deletes, so
-      // only a CLI push that tombstones a variant record reaches this arm.
-      deleted: true,
-      expectedBaseContentHash: baseContentHash,
-      intent: createProjectVersionIntent("value.delete", {
-        source: "server-variant-graph-cascade"
-      })
-    });
-  }
-}
 var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE, SCHEMA_RECORD_KINDS, DIALOGUE_SOURCE_RECORD_KINDS, NEO_VARIANT_SCHEMA_KEY_BY_ARGUMENT_NAME, VARIANT_CONSTRUCTOR_ARGS_SCHEMA_RECORD_KINDS;
 var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
     init_members();
+    init_neo_script_derived_bodies();
     init_localized_instance_override_writes();
     init_project_version_transaction_planning();
     init_members();
@@ -104959,6 +105591,10 @@ var init_project_version_schema_commit = __esm({
     init_virtual_instance_values();
     init_world_system_classes();
     init_neo_script_recompile_scope();
+    init_stored_value_shape();
+    init_owned_value_deletion();
+    init_evaluateInitializer();
+    init_virtual_instance_graph();
     SERVER_COMPILATION_PROJECT_CACHE_LIMIT = 4;
     serverCompilationProjectCache = /* @__PURE__ */ new Map();
     READ_ONLY_SOURCE_CONVERSION_INTENT_SOURCE = "server-readonly-source-conversion";
@@ -104989,77 +105625,6 @@ var init_project_version_schema_commit = __esm({
   }
 });
 
-// ../src/database/project-record-semantics.ts
-function projectRecordSemanticData(value) {
-  if (!isPlainRecord2(value)) return value;
-  const semantic = {};
-  for (const [key, child] of Object.entries(value)) {
-    if (SERVER_MANAGED_PROJECT_RECORD_FIELDS.has(key)) continue;
-    semantic[key] = child;
-  }
-  return semantic;
-}
-function projectRecordDataIsSemanticallyEqual(left, right) {
-  return canonicalJsonStringify2(projectRecordSemanticData(left)) === canonicalJsonStringify2(projectRecordSemanticData(right));
-}
-function canonicalJsonStringify2(value) {
-  return JSON.stringify(toCanonicalJsonValue2(value));
-}
-function toCanonicalJsonValue2(value) {
-  if (value === null) return null;
-  if (value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error("Cannot canonicalize a non-finite number.");
-    }
-    return value;
-  }
-  if (typeof value === "bigint") {
-    throw new Error("Cannot canonicalize bigint values.");
-  }
-  if (typeof value === "symbol") {
-    throw new Error("Cannot canonicalize symbol values.");
-  }
-  if (typeof value === "function") {
-    throw new Error("Cannot canonicalize function values.");
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => toCanonicalJsonValue2(item) ?? null);
-  }
-  if (!isPlainRecord2(value)) {
-    throw new Error("Cannot canonicalize a non-plain object.");
-  }
-  const canonical = {};
-  const entries = Object.entries(value).sort(
-    ([left], [right]) => left.localeCompare(right)
-  );
-  for (const [key, child] of entries) {
-    const canonicalChild = toCanonicalJsonValue2(child);
-    if (canonicalChild === void 0) continue;
-    canonical[key] = canonicalChild;
-  }
-  return canonical;
-}
-function isPlainRecord2(value) {
-  if (value === null || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-var SERVER_MANAGED_PROJECT_RECORD_FIELDS;
-var init_project_record_semantics = __esm({
-  "../src/database/project-record-semantics.ts"() {
-    "use strict";
-    SERVER_MANAGED_PROJECT_RECORD_FIELDS = /* @__PURE__ */ new Set([
-      "_id",
-      "projectId",
-      "createdAt",
-      "updatedAt"
-    ]);
-  }
-});
-
 // ../src/database/system-protection.ts
 function hasSystemDisallowedOperation(system, operation) {
   if (system === null || system === void 0) return false;
@@ -105995,7 +106560,7 @@ function stagedChangesRequireWorldLayerBindingValidation(current, changes) {
     const before = classesById.get(change.recordId);
     if (before === void 0) return true;
     const after = change.nextData;
-    if (!isPlainRecord(after)) return true;
+    if (!isPlainRecord2(after)) return true;
     if (before.extendsClassId !== after.extendsClassId) return true;
     if (isAbstractClass(before) !== isAbstractClass(after)) return true;
     if (!worldClassSystemBlockIsEqual(before.system, after.system)) return true;
@@ -106046,7 +106611,7 @@ function stagedAffectedWorldLayerLinkClassIds(args) {
       change.nextData
     ];
     for (const candidate of candidates) {
-      if (!isPlainRecord(candidate)) continue;
+      if (!isPlainRecord2(candidate)) continue;
       const relationKind = candidate.relationKind;
       if (typeof relationKind !== "string") continue;
       if (!isStagedWorldLayerLinkTargetRelationKind(relationKind)) continue;
@@ -106089,9 +106654,9 @@ function worldClassSystemBlockIsEqual(before, after) {
   );
 }
 function hasWorldLayerOverrideMetadata(record4) {
-  if (!isPlainRecord(record4)) return false;
+  if (!isPlainRecord2(record4)) return false;
   const value = record4.value;
-  if (!isPlainRecord(value)) return false;
+  if (!isPlainRecord2(value)) return false;
   return typeof value.layerOverrideValueId === "string";
 }
 function assertStagedProjectInterfaceValid(projected, changes) {
@@ -106231,7 +106796,7 @@ function candidateActionListenerRowIds(projected, actions) {
   for (const row of projected.values) {
     if (storedRowActionListeners(row).length > 0) candidates.add(row.id);
     if (actionSchemaKeys.size === 0) continue;
-    if (!isPlainRecord(row.value)) continue;
+    if (!isPlainRecord2(row.value)) continue;
     for (const schemaKey of actionSchemaKeys) {
       const childId = row.value[schemaKey];
       if (typeof childId === "string") candidates.add(childId);
@@ -106241,7 +106806,7 @@ function candidateActionListenerRowIds(projected, actions) {
 }
 function storedRowActionListeners(row) {
   const body = row.value;
-  if (!isPlainRecord(body)) return [];
+  if (!isPlainRecord2(body)) return [];
   const listeners = body.listeners;
   return Array.isArray(listeners) ? listeners : [];
 }
@@ -106319,7 +106884,7 @@ function authoredActionListeners(action) {
   if (defaultValue === void 0 || defaultValue === null) return [];
   if (!isLiteralValueContent(defaultValue)) return [];
   const body = defaultValue.value;
-  if (!isPlainRecord(body)) return [];
+  if (!isPlainRecord2(body)) return [];
   const listeners = body.listeners;
   return Array.isArray(listeners) ? listeners : [];
 }
@@ -106665,7 +107230,7 @@ function candidateVariantRowIds(projected, variantMembers) {
       candidates.add(row.id);
     }
     if (schemaKeys.size === 0) continue;
-    if (!isPlainRecord(row.value)) continue;
+    if (!isPlainRecord2(row.value)) continue;
     for (const schemaKey of schemaKeys) {
       const childId = row.value[schemaKey];
       if (typeof childId === "string") candidates.add(childId);
@@ -109209,7 +109774,7 @@ function extractProjectSnapshotDerivedEdges(source) {
       })
     });
   }
-  const record4 = asRecord3(source.data);
+  const record4 = asRecord4(source.data);
   if (source.recordKind === "dialogue-node" && record4 !== null && typeof record4.dialogueId === "string") {
     add({
       edgeKind: "dialogue-membership",
@@ -109220,7 +109785,7 @@ function extractProjectSnapshotDerivedEdges(source) {
   }
   if (source.recordKind === "value" && record4 !== null) {
     const body = record4.value;
-    if (Array.isArray(body) || asRecord3(body) !== null) {
+    if (Array.isArray(body) || asRecord4(body) !== null) {
       for (const targetKey of collectDirectBodyChildIds(body)) {
         add({
           edgeKind: "containment-child",
@@ -109263,14 +109828,14 @@ function extractProjectSnapshotDerivedEdges(source) {
       })
     });
   }
-  const constructorArgs = record4 === null ? null : asRecord3(record4.constructorArgs);
+  const constructorArgs = record4 === null ? null : asRecord4(record4.constructorArgs);
   return {
     edges: [...edges.values()].sort(compareEdges),
     complete: constructorArgs === null || Object.keys(constructorArgs).length === 0 || source.constructorAggregateEdges !== void 0
   };
 }
 function addStampBindingEdges(genericBindings, add) {
-  const bindings = asRecord3(genericBindings);
+  const bindings = asRecord4(genericBindings);
   if (bindings === null) return;
   for (const [parameterId, stampedMemberId] of Object.entries(bindings)) {
     if (typeof stampedMemberId !== "string") continue;
@@ -109323,7 +109888,7 @@ function compareEdges(left, right) {
   return edgeIdentity(left).localeCompare(edgeIdentity(right));
 }
 function collectDirectBodyChildIds(value) {
-  const candidates = Array.isArray(value) ? value : Object.values(asRecord3(value) ?? {});
+  const candidates = Array.isArray(value) ? value : Object.values(asRecord4(value) ?? {});
   return [
     ...new Set(
       candidates.filter(
@@ -109332,7 +109897,7 @@ function collectDirectBodyChildIds(value) {
     )
   ];
 }
-function asRecord3(value) {
+function asRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 var PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION, STORED_PROJECT_RECORD_ID_PATTERN;
@@ -109678,7 +110243,9 @@ function commitPreparationWorldScopeKinds(args) {
       (schemaClass2) => typeof schemaClass2.system?.worldKind === "string" ? [schemaClass2.system.worldKind] : []
     )
   );
-  if (args.changes.some((change) => change.recordKind === "class")) {
+  if (args.changes.some(
+    (change) => change.recordKind === "class" || change.recordKind === "internal-record-relation"
+  )) {
     return allKinds;
   }
   const kindsByClass = worldKindByClassId(args.postDocument);
@@ -110301,7 +110868,7 @@ function planCommitPreparationLoadedClosureScope(args) {
     if (rules.has("ancestor-paths") && record4.parentRecordKind !== null && record4.parentRecordKind !== void 0 && record4.parentRecordId !== null && record4.parentRecordId !== void 0) {
       rememberExact(record4.parentRecordKind, record4.parentRecordId);
     }
-    const canOwnStoredDescendants = record4.recordKind !== "value" || record4.data !== null && typeof record4.data === "object" && Reflect.get(record4.data, "value") !== null && typeof Reflect.get(record4.data, "value") === "object";
+    const canOwnStoredDescendants = record4.recordKind !== "value" || !isLiteralValueContent(record4.data) || !["string", "number", "boolean"].includes(typeof record4.data.value) || typeof record4.data.classId === "string" || isVirtualInstanceRootShape(record4.data);
     if (rules.has("descendants") && record4.includeDescendants !== false && canOwnStoredDescendants && (record4.recordKind === "member" || record4.recordKind === "value" || record4.recordKind === "class" || record4.recordKind === "variant")) {
       rememberRange({
         rangeKind: "children",
@@ -126069,7 +126636,7 @@ function normalizeSourceFiles(inputFiles) {
   return files;
 }
 function readSourceFile(value, index) {
-  const record4 = asRecord4(value, `Project source identity file ${index}`);
+  const record4 = asRecord5(value, `Project source identity file ${index}`);
   assertExactKeys(record4, ["path", "kind", "content"]);
   if (typeof record4.path !== "string" || !isSafeSourcePath(record4.path)) {
     throw new Error(
@@ -126104,7 +126671,7 @@ function isSafeSourcePath(path) {
   }
   return neoProjectSourceKind(path) !== null;
 }
-function asRecord4(value, label) {
+function asRecord5(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${label} must be an object.`);
   }
@@ -130077,7 +130644,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.47.0",
+      cliVersion: "0.47.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -136480,6 +137047,7 @@ function resolveWriteRowId(write, target, compiledAction, ctx, world) {
   const pointer = isObjectRecord2(target.pointer) ? target.pointer : target;
   const evalPointer2 = (p) => {
     const getter = {
+      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
       parameters: compiledAction.parameters ?? [],
       instructions: [{ type: "return", pointer: p }],
       typeInfo: { type: 0, required: false }
@@ -136533,6 +137101,7 @@ function printReport(report) {
 var init_dialogue_dryrun = __esm({
   "src/commands/dialogue-dryrun.ts"() {
     "use strict";
+    init_src();
     init_document();
     init_projection();
     init_neoscript2();
@@ -137118,7 +137687,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.47.0");
+    console.log("0.47.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -137234,8 +137803,7 @@ async function main() {
       await runDoctor2(workspace, {
         json,
         fix,
-        yes,
-        strict: boolFlag(args)
+        yes
       });
       return;
     }