@neocompose/cli 0.40.0 → 0.41.0

package/dist/neo.mjs

@@ -19441,7 +19441,7 @@ var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 4;
-    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "4.0";
+    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "4.1";
     PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
@@ -19459,6 +19459,7 @@ var init_project_schema_contract_generated = __esm({
           "system",
           "storage",
           "storageKey",
+          "distribution",
           "minValue",
           "maxValue",
           "decimalPoints",
@@ -19657,6 +19658,10 @@ var init_project_schema_contract_generated = __esm({
           "Visible",
           "Hidden"
         ],
+        "NeoSubtreeDistribution": [
+          "Sparse",
+          "Packed"
+        ],
         "NeoStringFormat": [
           "Localized",
           "Plain"
@@ -23829,6 +23834,7 @@ function fieldsForAnnotation(name, context, environment) {
   }
   if (name === "settings") return settingsFields(context);
   if (name === "storage") return storageFields(context);
+  if (name === "distribution") return distributionFields(context);
   if (name === "relations") return relationFields(context, environment);
   if (name === "system") {
     return context.kind === "class" || context.kind === "schema" || context.kind === "member" ? markerFields("NeoSystemAttribute") : null;
@@ -23901,6 +23907,12 @@ function settingsFields(context) {
     )
   );
 }
+function distributionFields(context) {
+  if (context.kind === "member" || context.kind === "type") {
+    return [{ name: "kind", type: "NeoSubtreeDistribution" }];
+  }
+  return null;
+}
 function storageFields(context) {
   if (context.kind === "class") {
     return [{ name: "allowed", type: "NeoAllowedStorage" }];
@@ -29447,7 +29459,7 @@ function projectDeclarationAnnotationNames(declaration) {
   ];
 }
 function projectMemberAnnotationNames(member) {
-  const names = ["id", "settings", "storage"];
+  const names = ["id", "settings", "storage", "distribution"];
   if (member?.type.name === "List") names.push("index", "column");
   return names;
 }
@@ -31044,6 +31056,8 @@ function annotationSignatureParameters(name) {
       return ["named settings"];
     case "storage":
       return ["StorageKind allowed"];
+    case "distribution":
+      return ["NeoSubtreeDistribution kind"];
     case "relations":
       return ["relation descriptors"];
     case "incomplete":
@@ -35728,6 +35742,7 @@ var init_document_contracts = __esm({
           "system",
           "storage",
           "storageKey",
+          "distribution",
           "minValue",
           "maxValue",
           "decimalPoints",
@@ -37029,6 +37044,11 @@ function memberFromDocument(record3, members, owners, classNames, context) {
     // user-authored unless its own document explicitly marks it as system.
     system: systemFromDocument(data.system, record3, "system"),
     storage: normalizedStorage(field("storage", null), record3),
+    // Read from the row's own document rather than through `field(...)`: an
+    // override that declares no distribution inherits, and resolving the
+    // chain here would emit the ancestor's explicit choice back into the
+    // override's source as phantom drift (P76 §2).
+    distribution: normalizedDistribution(data.distribution, record3),
     storageKey: normalizedStorageKey(field("storageKey", null), record3)
   };
   const primitiveKind = SIMPLE_MEMBER_KIND_BY_KIND.get(kind);
@@ -37378,6 +37398,9 @@ function memberToDocumentFields(member, baseData3) {
   } else if (isOverride && baseData3?.storage === 0) {
     fields.storage = 0;
   }
+  if (member.distribution !== null) {
+    fields.distribution = MEMBER_DISTRIBUTION.indexOf(member.distribution);
+  }
   if (member.storageKey !== null) fields.storageKey = member.storageKey;
   if (member.kind === "int" || member.kind === "float") {
     if (member.min !== null) fields.minValue = member.min;
@@ -38134,6 +38157,10 @@ function normalizedStorage(value, record3) {
   const storage = ordinalValue(value ?? 0, MEMBER_STORAGE, record3, "storage");
   return storage === "inherit" ? null : storage;
 }
+function normalizedDistribution(value, record3) {
+  if (value === void 0 || value === null) return null;
+  return ordinalValue(value, MEMBER_DISTRIBUTION, record3, "distribution");
+}
 function normalizedStorageKey(value, record3) {
   if (value === void 0 || value === null || value === "") {
     return null;
@@ -38258,7 +38285,7 @@ function invalidDocument(record3, path, message) {
     `${record3.recordKind}:${record3.recordId}.${path} ${message}.`
   );
 }
-var MEMBER_KIND, MEMBER_MODIFIERS, MEMBER_ACCESS, MEMBER_STORAGE, STRING_FORMAT, MEMBER_SEARCH_BY, MEMBER_SELECTION, FUNCTION_DISPATCH, FUNCTION_BODY, MEMBER_PAYLOAD, DICTIONARY_KEY, LIST_KIND, LIST_INDEX, COLUMN_VISIBILITY, COLUMN_PIN, COLUMN_OVERFLOW, GENERIC_BINDING, TYPE_KIND_BY_MEMBER_KIND, SIMPLE_MEMBER_KIND_BY_KIND, MEMBER_KIND_BY_KIND, TYPE_MEMBER_KIND_BY_KIND, MEMBER_IDENTITY_FIELDS, INHERITED_MEMBER_ORDINAL_FIELDS, CHAIN_RESOLVED_OPTIONAL_MEMBER_FIELDS;
+var MEMBER_KIND, MEMBER_MODIFIERS, MEMBER_ACCESS, MEMBER_STORAGE, MEMBER_DISTRIBUTION, STRING_FORMAT, MEMBER_SEARCH_BY, MEMBER_SELECTION, FUNCTION_DISPATCH, FUNCTION_BODY, MEMBER_PAYLOAD, DICTIONARY_KEY, LIST_KIND, LIST_INDEX, COLUMN_VISIBILITY, COLUMN_PIN, COLUMN_OVERFLOW, GENERIC_BINDING, TYPE_KIND_BY_MEMBER_KIND, SIMPLE_MEMBER_KIND_BY_KIND, MEMBER_KIND_BY_KIND, TYPE_MEMBER_KIND_BY_KIND, MEMBER_IDENTITY_FIELDS, INHERITED_MEMBER_ORDINAL_FIELDS, CHAIN_RESOLVED_OPTIONAL_MEMBER_FIELDS;
 var init_codecs = __esm({
   "src/project-manifest/record-adapters/codecs.ts"() {
     "use strict";
@@ -38297,6 +38324,7 @@ var init_codecs = __esm({
     MEMBER_MODIFIERS = ["virtual", "sealed", "abstract", "static"];
     MEMBER_ACCESS = ["public", "protected", "private"];
     MEMBER_STORAGE = ["inherit", "immutable", "save", "session"];
+    MEMBER_DISTRIBUTION = ["sparse", "packed"];
     STRING_FORMAT = ["localized", "plain"];
     MEMBER_SEARCH_BY = ["none", "memberKey"];
     MEMBER_SELECTION = ["single", "multi"];
@@ -40675,6 +40703,13 @@ function assertMember2(value, path) {
   }
   assertSystem(member.system, `${path}.system`);
   nullableStorage(member.storage, `${path}.storage`);
+  nullableDistribution(member.distribution, `${path}.distribution`);
+  if (member.distribution !== null && (member.kind === "computed" || member.kind === "function" || member.kind === "scriptFunction")) {
+    invalid(
+      `${path}.distribution`,
+      "a value-less member has no stored value to distribute."
+    );
+  }
   nullableNonEmptyString(member.storageKey, `${path}.storageKey`);
   if (member.isReadOnly === true) {
     if (owner.kind !== "classMember" && owner.kind !== "sharedClassMember") {
@@ -40738,6 +40773,12 @@ function assertMember2(value, path) {
     );
     arrayOf(member.indexes, `${path}.indexes`, assertListIndex);
     arrayOf(member.columns, `${path}.columns`, assertListColumn);
+    if (member.distribution === "packed" && member.listKind === "unordered") {
+      invalid(
+        `${path}.distribution`,
+        "cannot be packed while listKind is unordered: an unordered list's membership is the set of live rows carrying its id, so its entries occupy no position inside a parent row to be packed into."
+      );
+    }
     if (member.isReadOnly === true && Array.isArray(member.indexes) && member.indexes.length > 0) {
       invalid(`${path}.indexes`, "must be empty on a read-only member.");
     }
@@ -41823,6 +41864,10 @@ function nullableStorage(value, path) {
   if (value === null) return;
   stringIn(value, /* @__PURE__ */ new Set(["immutable", "save", "session"]), path);
 }
+function nullableDistribution(value, path) {
+  if (value === null) return;
+  stringIn(value, /* @__PURE__ */ new Set(["sparse", "packed"]), path);
+}
 function stringIn(value, allowed, path) {
   const result = stringAt(value, path);
   if (!allowed.has(result)) {
@@ -42065,7 +42110,8 @@ var init_validate = __esm({
       "overrideOf",
       "system",
       "storage",
-      "storageKey"
+      "storageKey",
+      "distribution"
     ];
     MEMBER_KEYS_BY_KIND = {
       null: [],
@@ -42669,6 +42715,148 @@ var init_member_storage = __esm({
   }
 });
 
+// ../src/models/members/member-kind-enum.ts
+var MemberKind;
+var init_member_kind_enum = __esm({
+  "../src/models/members/member-kind-enum.ts"() {
+    "use strict";
+    MemberKind = /* @__PURE__ */ ((MemberKind16) => {
+      MemberKind16[MemberKind16["Null"] = 0] = "Null";
+      MemberKind16[MemberKind16["Bool"] = 1] = "Bool";
+      MemberKind16[MemberKind16["Int"] = 2] = "Int";
+      MemberKind16[MemberKind16["String"] = 3] = "String";
+      MemberKind16[MemberKind16["Float"] = 4] = "Float";
+      MemberKind16[MemberKind16["Dictionary"] = 5] = "Dictionary";
+      MemberKind16[MemberKind16["List"] = 6] = "List";
+      MemberKind16[MemberKind16["Class"] = 7] = "Class";
+      MemberKind16[MemberKind16["Enum"] = 8] = "Enum";
+      MemberKind16[MemberKind16["Lookup"] = 9] = "Lookup";
+      MemberKind16[MemberKind16["NSProperty"] = 10] = "NSProperty";
+      MemberKind16[MemberKind16["Sprite"] = 11] = "Sprite";
+      MemberKind16[MemberKind16["Audio"] = 12] = "Audio";
+      MemberKind16[MemberKind16["Function"] = 13] = "Function";
+      MemberKind16[MemberKind16["Vector2"] = 14] = "Vector2";
+      MemberKind16[MemberKind16["Vector2Int"] = 15] = "Vector2Int";
+      MemberKind16[MemberKind16["Vector3"] = 16] = "Vector3";
+      MemberKind16[MemberKind16["Vector3Int"] = 17] = "Vector3Int";
+      MemberKind16[MemberKind16["DialogueLookup"] = 18] = "DialogueLookup";
+      MemberKind16[MemberKind16["Color"] = 19] = "Color";
+      MemberKind16[MemberKind16["Decimal"] = 20] = "Decimal";
+      MemberKind16[MemberKind16["Generic"] = 21] = "Generic";
+      MemberKind16[MemberKind16["Interface"] = 22] = "Interface";
+      MemberKind16[MemberKind16["NSFunction"] = 23] = "NSFunction";
+      MemberKind16[MemberKind16["FunctionRef"] = 24] = "FunctionRef";
+      MemberKind16[MemberKind16["NSDelegate"] = 25] = "NSDelegate";
+      MemberKind16[MemberKind16["NSAction"] = 26] = "NSAction";
+      MemberKind16[MemberKind16["Variant"] = 27] = "Variant";
+      return MemberKind16;
+    })(MemberKind || {});
+  }
+});
+
+// ../src/models/members/member-subtree-distribution.ts
+function isNeoSubtreeDistributionKind(value) {
+  return value === 0 /* Sparse */ || value === 1 /* Packed */;
+}
+function sparse(growth) {
+  return { distribution: 0 /* Sparse */, growth };
+}
+function resolveAutomatic(kind, settings) {
+  const rule = AUTOMATIC_MEMBER_DISTRIBUTION[kind];
+  if (rule === 1 /* Packed */) return PACKED;
+  if (rule === "valueLess") return void 0;
+  if (rule === "openSlot") {
+    throw new Error(
+      `automaticMemberDistribution: MemberKind.Generic has no automatic distribution. Substitute the concrete binding member first and pass its kind and settings.`
+    );
+  }
+  if (rule === "stringFormat") {
+    return settings.format === 1 /* Plain */ ? sparse("unboundedText") : PACKED;
+  }
+  if (rule === "selectionCardinality") {
+    return settings.selection === 1 /* Multi */ ? sparse("selectionCount") : PACKED;
+  }
+  return sparse(rule.sparse);
+}
+function automaticMemberDistribution(kind, settings) {
+  return resolveAutomatic(kind, settings)?.distribution;
+}
+function memberKindSupportsDistribution(kind) {
+  return AUTOMATIC_MEMBER_DISTRIBUTION[kind] !== "valueLess";
+}
+var AUTOMATIC_MEMBER_DISTRIBUTION, PACKED;
+var init_member_subtree_distribution = __esm({
+  "../src/models/members/member-subtree-distribution.ts"() {
+    "use strict";
+    init_member_kind_enum();
+    AUTOMATIC_MEMBER_DISTRIBUTION = {
+      /** A stored null has no growth axis. */
+      [0 /* Null */]: 1 /* Packed */,
+      /** Fixed scalar. */
+      [1 /* Bool */]: 1 /* Packed */,
+      /** Fixed scalar. */
+      [2 /* Int */]: 1 /* Packed */,
+      /**
+       * A localized value stores one localized-text id; plain text is unbounded.
+       * The per-locale bodies stay on their own records under either arm.
+       */
+      [3 /* String */]: "stringFormat",
+      /** Fixed scalar. */
+      [4 /* Float */]: 1 /* Packed */,
+      /** Entry count grows with content. */
+      [5 /* Dictionary */]: { sparse: "entryCount" },
+      /** Entry count grows with content. */
+      [6 /* List */]: { sparse: "entryCount" },
+      /** Schema and authored child count can grow. */
+      [7 /* Class */]: { sparse: "authoredChildren" },
+      /** The enum declaration bounds the selected option ids; enum edits recheck encoded size. */
+      [8 /* Enum */]: 1 /* Packed */,
+      /** Single selection stores at most one value id; multi-selection follows collection size. */
+      [9 /* Lookup */]: "selectionCardinality",
+      /** Computed property, no stored value. */
+      [10 /* NSProperty */]: "valueLess",
+      /** Fixed `fileId` and `sliceIndex` shape. */
+      [11 /* Sprite */]: 1 /* Packed */,
+      /** Fixed one-file-id shape. */
+      [12 /* Audio */]: 1 /* Packed */,
+      /** Declaration only, no stored value. */
+      [13 /* Function */]: "valueLess",
+      /** Fixed two-number shape. */
+      [14 /* Vector2 */]: 1 /* Packed */,
+      /** Fixed two-integer shape. */
+      [15 /* Vector2Int */]: 1 /* Packed */,
+      /** Fixed three-number shape. */
+      [16 /* Vector3 */]: 1 /* Packed */,
+      /** Fixed three-integer shape. */
+      [17 /* Vector3Int */]: 1 /* Packed */,
+      /** Single selection stores at most one dialogue id. */
+      [18 /* DialogueLookup */]: "selectionCardinality",
+      /** Fixed four-channel shape. */
+      [19 /* Color */]: 1 /* Packed */,
+      /** Exact decimals are arbitrary-length strings. */
+      [20 /* Decimal */]: { sparse: "unboundedText" },
+      /** The open slot has no automatic shape; an explicit member-chain choice still wins. */
+      [21 /* Generic */]: "openSlot",
+      /** Type information only; not a persistable member record kind. */
+      [22 /* Interface */]: "valueLess",
+      /** Declaration only, no stored value. */
+      [23 /* NSFunction */]: "valueLess",
+      /** Fixed one-member-id shape. */
+      [24 /* FunctionRef */]: 1 /* Packed */,
+      /** A closure can carry unbounded code and captures. */
+      [25 /* NSDelegate */]: { sparse: "closureBody" },
+      /** Listener count grows with content. */
+      [26 /* NSAction */]: { sparse: "listenerCount" },
+      /** Fixed class, variant, and optional bound-row ids. */
+      [27 /* Variant */]: 1 /* Packed */
+    };
+    PACKED = {
+      distribution: 1 /* Packed */,
+      growth: null
+    };
+  }
+});
+
 // ../src/models/core/world-system-kinds.generated.ts
 function isNeoWorldSystemClassKind(value) {
   if (typeof value !== "string") return false;
@@ -44435,45 +44623,6 @@ var init_classes = __esm({
   }
 });
 
-// ../src/models/members/member-kind-enum.ts
-var MemberKind;
-var init_member_kind_enum = __esm({
-  "../src/models/members/member-kind-enum.ts"() {
-    "use strict";
-    MemberKind = /* @__PURE__ */ ((MemberKind16) => {
-      MemberKind16[MemberKind16["Null"] = 0] = "Null";
-      MemberKind16[MemberKind16["Bool"] = 1] = "Bool";
-      MemberKind16[MemberKind16["Int"] = 2] = "Int";
-      MemberKind16[MemberKind16["String"] = 3] = "String";
-      MemberKind16[MemberKind16["Float"] = 4] = "Float";
-      MemberKind16[MemberKind16["Dictionary"] = 5] = "Dictionary";
-      MemberKind16[MemberKind16["List"] = 6] = "List";
-      MemberKind16[MemberKind16["Class"] = 7] = "Class";
-      MemberKind16[MemberKind16["Enum"] = 8] = "Enum";
-      MemberKind16[MemberKind16["Lookup"] = 9] = "Lookup";
-      MemberKind16[MemberKind16["NSProperty"] = 10] = "NSProperty";
-      MemberKind16[MemberKind16["Sprite"] = 11] = "Sprite";
-      MemberKind16[MemberKind16["Audio"] = 12] = "Audio";
-      MemberKind16[MemberKind16["Function"] = 13] = "Function";
-      MemberKind16[MemberKind16["Vector2"] = 14] = "Vector2";
-      MemberKind16[MemberKind16["Vector2Int"] = 15] = "Vector2Int";
-      MemberKind16[MemberKind16["Vector3"] = 16] = "Vector3";
-      MemberKind16[MemberKind16["Vector3Int"] = 17] = "Vector3Int";
-      MemberKind16[MemberKind16["DialogueLookup"] = 18] = "DialogueLookup";
-      MemberKind16[MemberKind16["Color"] = 19] = "Color";
-      MemberKind16[MemberKind16["Decimal"] = 20] = "Decimal";
-      MemberKind16[MemberKind16["Generic"] = 21] = "Generic";
-      MemberKind16[MemberKind16["Interface"] = 22] = "Interface";
-      MemberKind16[MemberKind16["NSFunction"] = 23] = "NSFunction";
-      MemberKind16[MemberKind16["FunctionRef"] = 24] = "FunctionRef";
-      MemberKind16[MemberKind16["NSDelegate"] = 25] = "NSDelegate";
-      MemberKind16[MemberKind16["NSAction"] = 26] = "NSAction";
-      MemberKind16[MemberKind16["Variant"] = 27] = "Variant";
-      return MemberKind16;
-    })(MemberKind || {});
-  }
-});
-
 // ../src/models/members/structured-leaf-fields.ts
 function isStructuredLeafKind(kind) {
   return Object.prototype.hasOwnProperty.call(STRUCTURED_LEAF_FIELDS, kind);
@@ -45322,6 +45471,12 @@ function hasValidStorageField(v, allowNull) {
   if (typeof v.kind !== "number") return false;
   return memberKindSupportsStorage(v.kind);
 }
+function hasValidDistributionField(v) {
+  if (v.distribution === void 0) return true;
+  if (!isNeoSubtreeDistributionKind(v.distribution)) return false;
+  if (typeof v.kind !== "number") return false;
+  return memberKindSupportsDistribution(v.kind);
+}
 function isMemberBase(value) {
   const v = value;
   if (v?.kind === 22 /* Interface */) return false;
@@ -45345,6 +45500,7 @@ function isMemberBase(value) {
     return false;
   }
   if (!hasValidStorageField(v, true)) return false;
+  if (!hasValidDistributionField(v)) return false;
   const storageKey = getField(value, "storageKey");
   if (storageKey !== void 0 && storageKey !== null && typeof storageKey !== "string")
     return false;
@@ -45443,6 +45599,7 @@ function isMemberOverrideBase(value) {
     return false;
   }
   if (!hasValidStorageField(v, false)) return false;
+  if (!hasValidDistributionField(v)) return false;
   if (v.defaultValue !== void 0 && v.defaultValue !== null && !isMemberValueBase(v.defaultValue)) {
     return false;
   }
@@ -45686,6 +45843,7 @@ var init_member_kinds = __esm({
     init_classes();
     init_member_kind_enum();
     init_member_storage();
+    init_member_subtree_distribution();
     init_structured_leaf_fields();
     init_member_kind_enum();
     FunctionArgumentReservedNames = /* @__PURE__ */ new Set([
@@ -46280,6 +46438,7 @@ var init_world_system_classes_generated = __esm({
   "../src/models/classes/world-system-classes.generated.ts"() {
     "use strict";
     init_member_storage();
+    init_member_subtree_distribution();
     init_classes();
     init_member_kinds();
     WORLD_GRID_CHILDREN_MEMBER_ID = "system_98578ba3-a70e-4397-9283-996a898d44c8";
@@ -46373,6 +46532,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultValue: "",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "Name"
           }
@@ -46389,6 +46549,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultValue: "",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "Name"
           },
@@ -46421,6 +46582,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultValue: "",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "Name"
           },
@@ -46453,6 +46615,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultValue: "",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "Name"
           },
@@ -46483,6 +46646,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultValue: "",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "Name"
           },
@@ -46570,6 +46734,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultValue: "",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "Name"
           },
@@ -47332,6 +47497,7 @@ var init_world_system_classes_generated = __esm({
             memberKind: "string",
             defaultInitializerCode: "clipKey",
             format: 1 /* Plain */,
+            distribution: 1 /* Packed */,
             requirement: 1 /* Required */,
             schemaKey: "ClipKey"
           }
@@ -48172,6 +48338,11 @@ function substituteMember(member, env, members, preResolvedMember) {
     } else {
       delete substituted.storageKey;
     }
+    if (resolved.distribution !== void 0) {
+      substituted.distribution = resolved.distribution;
+    } else {
+      delete substituted.distribution;
+    }
     if (resolved.modifier !== void 0) {
       substituted.modifier = resolved.modifier;
     } else {
@@ -48719,10 +48890,31 @@ function pickInstanceProvenance(source) {
     ...source.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: source.instanceVariantRowValueId }
   };
 }
+function canonicalInstanceProvenanceViolation(value) {
+  const constructorArgs = "constructorArgs" in value ? value.constructorArgs : void 0;
+  const constructorId = "instanceConstructorId" in value ? value.instanceConstructorId : void 0;
+  const variantId = "instanceVariantId" in value ? value.instanceVariantId : void 0;
+  if (constructorArgs !== void 0 && constructorId === void 0 && typeof variantId !== "string") {
+    return "constructor-args-without-stamp";
+  }
+  if (typeof constructorId === "string" && constructorArgs === void 0) {
+    return "named-constructor-without-args";
+  }
+  if (constructorId === null && constructorArgs !== void 0 && typeof constructorArgs === "object" && constructorArgs !== null && !Array.isArray(constructorArgs) && Object.keys(constructorArgs).length > 0) {
+    return "implicit-constructor-with-args";
+  }
+  if ("instanceVariantRowValueId" in value && typeof value.instanceVariantRowValueId === "string" && typeof variantId !== "string") {
+    return "variant-row-without-variant";
+  }
+  return null;
+}
 function isVirtualInstanceRootShape(value) {
   if (value.instanceConstructorId !== void 0) return true;
   return typeof value.instanceVariantId === "string";
 }
+function isCollapseStampedInstanceRoot(value) {
+  return isLiteralValueContent(value) && isVirtualInstanceRootShape(value);
+}
 function carriesCompleteConstructionRecipe(value) {
   if (!isVirtualInstanceRootShape(value)) return false;
   if (value.instanceConstructorId === null) return true;
@@ -49359,6 +49551,463 @@ var init_read_only_members = __esm({
   }
 });
 
+// ../src/models/members/member-value-id.ts
+function derivedMemberValueId(memberId) {
+  return inSystemRecordNamespaceOf(
+    memberId,
+    v5_default(withoutSystemRecordIdPrefix(memberId), NEO_MEMBER_VALUE_NAMESPACE)
+  );
+}
+function virtualValueId(instanceRootId, sourceIdentity3) {
+  return inSystemRecordNamespaceOf(
+    instanceRootId,
+    v5_default(
+      `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity3}`,
+      NEO_VIRTUAL_VALUE_NAMESPACE
+    )
+  );
+}
+function pendingVirtualValueId(pendingInstanceRootId, sourceIdentity3) {
+  return `${PENDING_VIRTUAL_VALUE_PREFIX}${encodeURIComponent(pendingInstanceRootId)}:${encodeURIComponent(sourceIdentity3)}`;
+}
+function pendingVirtualValueIdentity(token) {
+  if (!token.startsWith(PENDING_VIRTUAL_VALUE_PREFIX)) return null;
+  const payload = token.slice(PENDING_VIRTUAL_VALUE_PREFIX.length);
+  const separator = payload.indexOf(":");
+  if (separator < 0) return null;
+  return {
+    instanceRootId: decodeURIComponent(payload.slice(0, separator)),
+    sourceIdentity: decodeURIComponent(payload.slice(separator + 1))
+  };
+}
+function pendingMemberValueId(pendingMemberId) {
+  return `${PENDING_MEMBER_VALUE_PREFIX}${encodeURIComponent(pendingMemberId)}`;
+}
+function pendingMemberValueMemberId(token) {
+  if (!token.startsWith(PENDING_MEMBER_VALUE_PREFIX)) return null;
+  return decodeURIComponent(token.slice(PENDING_MEMBER_VALUE_PREFIX.length));
+}
+var NEO_MEMBER_VALUE_NAMESPACE, NEO_VIRTUAL_VALUE_NAMESPACE, PENDING_VIRTUAL_VALUE_PREFIX, PENDING_MEMBER_VALUE_PREFIX;
+var init_member_value_id = __esm({
+  "../src/models/members/member-value-id.ts"() {
+    "use strict";
+    init_dist_node();
+    init_system_record_id();
+    NEO_MEMBER_VALUE_NAMESPACE = "7f2b9c14-58d6-5a07-b3e1-4c9d0a6f8b25";
+    NEO_VIRTUAL_VALUE_NAMESPACE = "3e8ca0b3-e3f1-5d5f-bf2f-6ab5ee3896d0";
+    PENDING_VIRTUAL_VALUE_PREFIX = "__pending__:virtual-value:";
+    PENDING_MEMBER_VALUE_PREFIX = "__pending__:member-value:";
+  }
+});
+
+// ../src/models/members/packed-value-encoding.ts
+function isPackedValueEnvelope(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.hasOwn(value, PACKED_VALUE_ENTRY_KEY);
+}
+function rowCarriesPackedValueContent(content) {
+  if (containerHoldsPackedEntry(content.value)) return true;
+  return containerHoldsPackedEntry(content.constructorArgs);
+}
+function expandPackedValueRows(rows) {
+  let firstPacked = -1;
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === void 0 || !rowCarriesPackedValueContent(row)) continue;
+    firstPacked = index;
+    break;
+  }
+  if (firstPacked < 0) return rows;
+  const expanded = rows.slice(0, firstPacked);
+  for (let index = firstPacked; index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === void 0) continue;
+    const decoded = decodePackedValueRow(row);
+    expanded.push(decoded.row, ...decoded.children);
+  }
+  return expanded;
+}
+function expandPackedDocumentValues(document) {
+  const stored = document.values;
+  const expanded = expandPackedValueRows(stored);
+  if (expanded === stored) return document;
+  return { ...document, values: expanded };
+}
+function decodePackedValueRow(row) {
+  if (!rowCarriesPackedValueContent(row)) {
+    return { row, children: NO_CHILDREN, packedChildIdsByParentId: NO_EDGES };
+  }
+  const state = {
+    edges: /* @__PURE__ */ new Map(),
+    seenIds: /* @__PURE__ */ new Set([row.id]),
+    projectId: row.projectId,
+    mapKey: row.mapKey
+  };
+  const children = [];
+  const scope = {
+    state,
+    ownerId: row.id,
+    ownerLabel: `value "${row.id}"`,
+    constructionRootId: isCollapseStampedInstanceRoot(row) ? row.id : null
+  };
+  const value = decodeContentField(row.value, "value", scope, children);
+  const constructorArgs = decodeContentField(
+    isLiteralValueContent(row) ? row.constructorArgs : void 0,
+    "constructorArgs",
+    scope,
+    children
+  );
+  return {
+    row: withDecodedContent(row, value, constructorArgs),
+    children,
+    packedChildIdsByParentId: state.edges
+  };
+}
+function encodePackedValueRow(args) {
+  const scope = {
+    parent: args.parent,
+    rowsById: args.rowsById,
+    packedChildIdsByParentId: args.packedChildIdsByParentId,
+    ownerId: args.parent.id,
+    ownerLabel: `value "${args.parent.id}"`,
+    constructionRootId: isCollapseStampedInstanceRoot(args.parent) ? args.parent.id : null
+  };
+  const pending = pendingPackedChildIds(scope);
+  if (pending === null) return args.parent;
+  const value = encodeContentField(args.parent.value, pending, scope);
+  const constructorArgs = encodeContentField(
+    isLiteralValueContent(args.parent) ? args.parent.constructorArgs : void 0,
+    pending,
+    scope
+  );
+  assertEveryChildPlaced(pending, scope);
+  return withDecodedContent(args.parent, value, constructorArgs);
+}
+function canonicalPackedChildId(args) {
+  if (args.constructionRootId === null) return null;
+  if (typeof args.sourceValueId !== "string") return null;
+  if (args.sourceValueId.length === 0) return null;
+  return virtualValueId(args.constructionRootId, args.sourceValueId);
+}
+function decodeContentField(container, field, scope, children) {
+  if (!containerHoldsPackedEntry(container)) return null;
+  if (Array.isArray(container)) {
+    return {
+      content: container.map(
+        (entry, index) => isPackedValueEnvelope(entry) ? decodeEnvelope(entry, `${field}[${index}]`, scope, children) : entry
+      )
+    };
+  }
+  const decoded = {};
+  for (const [key, entry] of Object.entries(
+    container
+  )) {
+    decoded[key] = isPackedValueEnvelope(entry) ? decodeEnvelope(
+      entry,
+      `${field}[${JSON.stringify(key)}]`,
+      scope,
+      children
+    ) : entry;
+  }
+  return { content: decoded };
+}
+function decodeEnvelope(envelope, position, scope, children) {
+  const label = `Packed value entry at ${scope.ownerLabel}.${position}`;
+  const entry = envelope[PACKED_VALUE_ENTRY_KEY];
+  assertDecodableEntry(entry, label);
+  const id2 = packedEntryLogicalId(entry, label, scope.constructionRootId);
+  if (scope.state.seenIds.has(id2)) {
+    throw new PackedValueEncodingError(
+      `${label} resolves to id "${id2}", which another row in the same packed payload already claims.`
+    );
+  }
+  scope.state.seenIds.add(id2);
+  registerEdge(scope.state.edges, scope.ownerId, id2);
+  const childScope = {
+    state: scope.state,
+    ownerId: id2,
+    ownerLabel: `packed value "${id2}"`,
+    constructionRootId: isCollapseStampedInstanceRoot(entry) ? id2 : scope.constructionRootId
+  };
+  const nested = [];
+  children.push(logicalChildRow(entry, id2, childScope, nested));
+  children.push(...nested);
+  return id2;
+}
+function logicalChildRow(entry, id2, scope, children) {
+  const rowFields = {
+    id: id2,
+    projectId: scope.state.projectId,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
+    ...scope.state.mapKey === void 0 ? {} : { mapKey: scope.state.mapKey },
+    ...entry.genericBindings === void 0 ? {} : { genericBindings: entry.genericBindings },
+    ...entry.sourceValueId === void 0 ? {} : { sourceValueId: entry.sourceValueId }
+  };
+  if (isInitValueContent(entry)) return { ...rowFields, init: entry.init };
+  const value = decodeContentField(entry.value, "value", scope, children);
+  const constructorArgs = decodeContentField(
+    entry.constructorArgs,
+    "constructorArgs",
+    scope,
+    children
+  );
+  return {
+    ...rowFields,
+    ...literalContent(entry, value, constructorArgs)
+  };
+}
+function packedEntryLogicalId(entry, label, constructionRootId) {
+  const canonical = canonicalPackedChildId({
+    constructionRootId,
+    sourceValueId: entry.sourceValueId
+  });
+  const stored = entry.id;
+  if (stored === void 0) {
+    if (canonical === null) {
+      throw new PackedValueEncodingError(
+        `${label} stores no "id" and its position derives none: only a deterministic child of an enclosing construction root, stamped with a "sourceValueId", may omit its logical id.`
+      );
+    }
+    return canonical;
+  }
+  if (typeof stored !== "string" || stored.length === 0) {
+    throw new PackedValueEncodingError(
+      `${label} stores an "id" that is not a non-empty string.`
+    );
+  }
+  if (stored === canonical) {
+    throw new PackedValueEncodingError(
+      `${label} stores id "${stored}", which its position already derives; a derivable id must be omitted rather than repeated.`
+    );
+  }
+  return stored;
+}
+function assertDecodableEntry(entry, label) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    throw new PackedValueEncodingError(`${label} is not an object.`);
+  }
+  for (const field of PACKED_ENTRY_FORBIDDEN_FIELDS) {
+    if (!Object.hasOwn(entry, field)) continue;
+    throw new PackedValueEncodingError(
+      `${label} stores "${field}", which decoding derives from its owning row.`
+    );
+  }
+  if (!("createdAt" in entry) || typeof entry.createdAt !== "number") {
+    throw new PackedValueEncodingError(
+      `${label} stores no numeric "createdAt".`
+    );
+  }
+  if (!("updatedAt" in entry) || typeof entry.updatedAt !== "number") {
+    throw new PackedValueEncodingError(
+      `${label} stores no numeric "updatedAt".`
+    );
+  }
+  const hasValue = Object.hasOwn(entry, "value");
+  const hasInit = Object.hasOwn(entry, "init");
+  if (hasValue && hasInit) {
+    throw new PackedValueEncodingError(
+      `${label} stores both "value" and "init"; a value container holds exactly one.`
+    );
+  }
+  if (!hasValue && !hasInit) {
+    throw new PackedValueEncodingError(
+      `${label} stores neither "value" nor "init"; a value container holds exactly one.`
+    );
+  }
+  if (hasInit && !isInitValueContent(entry)) {
+    throw new PackedValueEncodingError(
+      `${label} stores an "init" that is not a valid initializer body.`
+    );
+  }
+  if (hasValue && !isLiteralValueContent(entry)) {
+    throw new PackedValueEncodingError(
+      `${label} stores a "value" whose class or construction stamp is malformed.`
+    );
+  }
+}
+function pendingPackedChildIds(scope) {
+  const childIds = scope.packedChildIdsByParentId.get(scope.ownerId);
+  if (childIds === void 0 || childIds.length === 0) return null;
+  return new Set(childIds);
+}
+function assertEveryChildPlaced(pending, scope) {
+  if (pending.size === 0) return;
+  const [missing] = [...pending];
+  throw new PackedValueEncodingError(
+    `Cannot pack child "${missing}" into ${scope.ownerLabel}: no stored position of that row holds its id.`
+  );
+}
+function encodeContentField(container, pending, scope) {
+  if (Array.isArray(container)) {
+    let changed2 = false;
+    const encoded2 = container.map((entry, index) => {
+      if (typeof entry !== "string" || !pending.has(entry)) return entry;
+      changed2 = true;
+      return encodeEnvelope(entry, `[${index}]`, pending, scope);
+    });
+    return changed2 ? { content: encoded2 } : null;
+  }
+  if (typeof container !== "object" || container === null) return null;
+  let changed = false;
+  const encoded = {};
+  for (const [key, entry] of Object.entries(
+    container
+  )) {
+    if (typeof entry !== "string" || !pending.has(entry)) {
+      encoded[key] = entry;
+      continue;
+    }
+    changed = true;
+    encoded[key] = encodeEnvelope(
+      entry,
+      `[${JSON.stringify(key)}]`,
+      pending,
+      scope
+    );
+  }
+  return changed ? { content: encoded } : null;
+}
+function encodeEnvelope(childId, position, pending, scope) {
+  pending.delete(childId);
+  const child = scope.rowsById.get(childId);
+  if (child === void 0) {
+    throw new PackedValueEncodingError(
+      `Cannot pack child "${childId}" into ${scope.ownerLabel}: its logical row was not supplied.`
+    );
+  }
+  if (child.projectId !== scope.parent.projectId) {
+    throw new PackedValueEncodingError(
+      `Cannot pack child "${childId}" into ${scope.ownerLabel}: it belongs to project "${child.projectId}" rather than "${scope.parent.projectId}".`
+    );
+  }
+  if (child.containerId !== void 0) {
+    throw new PackedValueEncodingError(
+      `Cannot pack child "${childId}" into ${scope.ownerLabel}: it is an entry of unordered list "${child.containerId}", whose membership is the set of live rows and cannot survive without one.`
+    );
+  }
+  if (child.mapKey !== scope.parent.mapKey) {
+    throw new PackedValueEncodingError(
+      `Cannot pack child "${childId}" into ${scope.ownerLabel}: it is stamped for storage partition "${child.mapKey ?? "main"}" rather than its parent's "${scope.parent.mapKey ?? "main"}".`
+    );
+  }
+  const childScope = {
+    ...scope,
+    ownerId: childId,
+    ownerLabel: `packed value "${childId}"`,
+    constructionRootId: isCollapseStampedInstanceRoot(child) ? childId : scope.constructionRootId
+  };
+  const childPending = pendingPackedChildIds(childScope);
+  const canonical = canonicalPackedChildId({
+    constructionRootId: scope.constructionRootId,
+    sourceValueId: child.sourceValueId
+  });
+  const storedId = canonical === childId ? void 0 : childId;
+  if (childPending === null)
+    return {
+      [PACKED_VALUE_ENTRY_KEY]: packedEntry(child, null, null, storedId)
+    };
+  const value = encodeContentField(child.value, childPending, childScope);
+  const constructorArgs = encodeContentField(
+    isLiteralValueContent(child) ? child.constructorArgs : void 0,
+    childPending,
+    childScope
+  );
+  assertEveryChildPlaced(childPending, childScope);
+  return {
+    [PACKED_VALUE_ENTRY_KEY]: packedEntry(
+      child,
+      value,
+      constructorArgs,
+      storedId
+    )
+  };
+}
+function packedEntry(child, value, constructorArgs, storedId) {
+  const identity2 = storedId === void 0 ? {} : { id: storedId };
+  const trailer = {
+    ...child.genericBindings === void 0 ? {} : { genericBindings: child.genericBindings },
+    ...child.sourceValueId === void 0 ? {} : { sourceValueId: child.sourceValueId },
+    createdAt: child.createdAt,
+    updatedAt: child.updatedAt
+  };
+  if (isInitValueContent(child)) {
+    return { ...identity2, init: child.init, ...trailer };
+  }
+  return {
+    ...identity2,
+    ...literalContent(child, value, constructorArgs),
+    ...trailer
+  };
+}
+function literalContent(content, value, constructorArgs) {
+  if (!isLiteralValueContent(content)) {
+    throw new PackedValueEncodingError(
+      `Value container has no literal "value" to encode.`
+    );
+  }
+  const provenance = pickInstanceProvenance(content);
+  return {
+    value: value === null ? content.value : value.content,
+    ...Object.hasOwn(content, "classId") ? { classId: content.classId } : {},
+    ...provenance,
+    ...constructorArgs === null ? {} : { constructorArgs: asConstructorArgs(constructorArgs.content) }
+  };
+}
+function withDecodedContent(row, value, constructorArgs) {
+  if (value === null && constructorArgs === null) return row;
+  return { ...row, ...literalContent(row, value, constructorArgs) };
+}
+function asConstructorArgs(content) {
+  if (content === null) return null;
+  if (typeof content !== "object" || Array.isArray(content)) {
+    throw new PackedValueEncodingError(
+      `Value container stores "constructorArgs" that is not a record.`
+    );
+  }
+  return content;
+}
+function containerHoldsPackedEntry(container) {
+  if (Array.isArray(container)) {
+    return container.some((entry) => isPackedValueEnvelope(entry));
+  }
+  if (typeof container !== "object" || container === null) return false;
+  for (const entry of Object.values(container)) {
+    if (isPackedValueEnvelope(entry)) return true;
+  }
+  return false;
+}
+function registerEdge(edges, ownerId, childId) {
+  const existing = edges.get(ownerId);
+  if (existing === void 0) edges.set(ownerId, [childId]);
+  else existing.push(childId);
+}
+var PACKED_VALUE_ENTRY_KEY, PackedValueEncodingError, NO_CHILDREN, NO_EDGES, PACKED_ENTRY_FORBIDDEN_FIELDS;
+var init_packed_value_encoding = __esm({
+  "../src/models/members/packed-value-encoding.ts"() {
+    "use strict";
+    init_instance_provenance();
+    init_member_kinds();
+    init_member_value_id();
+    PACKED_VALUE_ENTRY_KEY = "~packed";
+    PackedValueEncodingError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "PackedValueEncodingError";
+      }
+    };
+    NO_CHILDREN = [];
+    NO_EDGES = /* @__PURE__ */ new Map();
+    PACKED_ENTRY_FORBIDDEN_FIELDS = [
+      "projectId",
+      "containerId",
+      "mapKey"
+    ];
+  }
+});
+
 // ../src/models/members/member-kinds-db-response.ts
 var init_member_kinds_db_response = __esm({
   "../src/models/members/member-kinds-db-response.ts"() {
@@ -51808,6 +52457,45 @@ var init_enum_reference_sites = __esm({
   }
 });
 
+// ../src/models/members/effective-distribution.ts
+function declaredMemberDistribution(memberId, members) {
+  return walkExtendsMemberChain(memberId, members, (a) => {
+    const distribution = a.distribution;
+    return isNeoSubtreeDistributionKind(distribution) ? distribution : void 0;
+  });
+}
+function concreteMember(member, members, env) {
+  const resolved = resolveMember2(member, members);
+  if (env === void 0) return resolved;
+  return substituteMember(member, env, members, resolved);
+}
+function distributionSettings(concrete) {
+  return {
+    format: isLocalizedStringMember(concrete) ? 0 /* Localized */ : 1 /* Plain */,
+    selection: isMultiSelectionMember(concrete) ? 1 /* Multi */ : 0 /* Single */
+  };
+}
+function effectiveMemberDistribution(member, members, env) {
+  const concrete = concreteMember(member, members, env);
+  if (isNeoSubtreeDistributionKind(concrete.distribution)) {
+    return concrete.distribution;
+  }
+  if (concrete.kind === 21 /* Generic */) return void 0;
+  return automaticMemberDistribution(
+    concrete.kind,
+    distributionSettings(concrete)
+  );
+}
+var init_effective_distribution = __esm({
+  "../src/models/members/effective-distribution.ts"() {
+    "use strict";
+    init_member_kinds();
+    init_member_subtree_distribution();
+    init_inheritance();
+    init_generics();
+  }
+});
+
 // ../src/models/members/list-indexes.ts
 function validateListIndexDefinitions(ctx, listMember) {
   const errors = [];
@@ -51945,11 +52633,30 @@ function resolveListIndexDefinitions(ctx, listMember) {
     };
   });
 }
+function validateListDistribution(ctx, member) {
+  if (declaredMemberDistribution(member.id, ctx.members) !== 1 /* Packed */) {
+    return [];
+  }
+  try {
+    const resolved = resolveMember2(member, ctx.members);
+    if (!isMemberListBase(resolved)) return [];
+    if (listKindOf(resolved) !== 1 /* Unordered */) return [];
+  } catch {
+    return [];
+  }
+  return [
+    {
+      memberId: member.id,
+      message: `List "${member.name}" (${member.id}) cannot select a packed distribution while its listKind is unordered: an unordered list's membership is the set of live rows carrying its id, so its entries occupy no position inside a parent row to be packed into.`
+    }
+  ];
+}
 function validateDocumentListIndexes(ctx) {
   const errors = [];
   for (const member of ctx.members) {
     if (member.kind !== 6 /* List */) continue;
     errors.push(...validateListIndexDefinitions(ctx, member));
+    errors.push(...validateListDistribution(ctx, member));
     if (!isMemberOverrideMarker(member)) continue;
     if (getField(member, "indexes") !== void 0) {
       errors.push({
@@ -52073,6 +52780,8 @@ var init_list_indexes = __esm({
   "../src/models/members/list-indexes.ts"() {
     "use strict";
     init_member_kinds();
+    init_effective_distribution();
+    init_member_subtree_distribution();
     init_core();
     init_generics();
     init_inheritance();
@@ -52469,7 +53178,7 @@ function isStringArray(value) {
   if (!Array.isArray(value)) return false;
   return value.every(isString);
 }
-var ProjectVersionBumpKind, ProjectRecordKind, ProjectVersionTransactionOperation;
+var ProjectVersionBumpKind, ProjectRecordKind, ProjectVersionTransactionOperation, ProjectVersionRecordOperation;
 var init_project_version_types = __esm({
   "../src/models/project/project-version-types.ts"() {
     "use strict";
@@ -52517,6 +53226,11 @@ var init_project_version_types = __esm({
       CompactBaseline: "compact-baseline",
       Migration: "migration"
     };
+    ProjectVersionRecordOperation = {
+      Create: "create",
+      Update: "update",
+      Delete: "delete"
+    };
   }
 });
 
@@ -52562,63 +53276,16 @@ var init_delete_member_response = __esm({
   }
 });
 
-// ../src/models/members/member-value-id.ts
-function derivedMemberValueId(memberId) {
-  return inSystemRecordNamespaceOf(
-    memberId,
-    v5_default(withoutSystemRecordIdPrefix(memberId), NEO_MEMBER_VALUE_NAMESPACE)
-  );
-}
-function virtualValueId(instanceRootId, sourceIdentity3) {
-  return inSystemRecordNamespaceOf(
-    instanceRootId,
-    v5_default(
-      `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity3}`,
-      NEO_VIRTUAL_VALUE_NAMESPACE
-    )
-  );
-}
-function pendingVirtualValueId(pendingInstanceRootId, sourceIdentity3) {
-  return `${PENDING_VIRTUAL_VALUE_PREFIX}${encodeURIComponent(pendingInstanceRootId)}:${encodeURIComponent(sourceIdentity3)}`;
-}
-function pendingVirtualValueIdentity(token) {
-  if (!token.startsWith(PENDING_VIRTUAL_VALUE_PREFIX)) return null;
-  const payload = token.slice(PENDING_VIRTUAL_VALUE_PREFIX.length);
-  const separator = payload.indexOf(":");
-  if (separator < 0) return null;
-  return {
-    instanceRootId: decodeURIComponent(payload.slice(0, separator)),
-    sourceIdentity: decodeURIComponent(payload.slice(separator + 1))
-  };
-}
-function pendingMemberValueId(pendingMemberId) {
-  return `${PENDING_MEMBER_VALUE_PREFIX}${encodeURIComponent(pendingMemberId)}`;
-}
-function pendingMemberValueMemberId(token) {
-  if (!token.startsWith(PENDING_MEMBER_VALUE_PREFIX)) return null;
-  return decodeURIComponent(token.slice(PENDING_MEMBER_VALUE_PREFIX.length));
-}
-var NEO_MEMBER_VALUE_NAMESPACE, NEO_VIRTUAL_VALUE_NAMESPACE, PENDING_VIRTUAL_VALUE_PREFIX, PENDING_MEMBER_VALUE_PREFIX;
-var init_member_value_id = __esm({
-  "../src/models/members/member-value-id.ts"() {
-    "use strict";
-    init_dist_node();
-    init_system_record_id();
-    NEO_MEMBER_VALUE_NAMESPACE = "7f2b9c14-58d6-5a07-b3e1-4c9d0a6f8b25";
-    NEO_VIRTUAL_VALUE_NAMESPACE = "3e8ca0b3-e3f1-5d5f-bf2f-6ab5ee3896d0";
-    PENDING_VIRTUAL_VALUE_PREFIX = "__pending__:virtual-value:";
-    PENDING_MEMBER_VALUE_PREFIX = "__pending__:member-value:";
-  }
-});
-
 // ../src/models/members/index.ts
 var init_members = __esm({
   "../src/models/members/index.ts"() {
     "use strict";
     init_member_storage();
+    init_member_subtree_distribution();
     init_read_only_members();
     init_member_kinds();
     init_structured_leaf_fields();
+    init_packed_value_encoding();
     init_member_kinds_db_response();
     init_unordered_list_membership();
     init_storage_partitions();
@@ -52626,6 +53293,7 @@ var init_members = __esm({
     init_enum_reference_sites();
     init_list_indexes();
     init_effective_storage();
+    init_effective_distribution();
     init_effective_member_docs();
     init_value_responses();
     init_edit_member_props();
@@ -53422,6 +54090,10 @@ function emitMember(context, member, enclosingClassId) {
         ...member.storageKey ? [`key: ${quote(member.storageKey)}`] : []
       ].join(", ")})`
     ] : [],
+    // Only an explicitly stored field is emitted. The automatic result of
+    // P76 §1 is never materialized into source, so a member that omits the
+    // annotation round-trips as an omission.
+    ...member.distribution ? [`@distribution(kind: .${enumCase(member.distribution)})`] : [],
     ...memberSettings(context, member),
     ...listAnnotations(member),
     ...member.system ? [systemAnnotation2(member.system)] : []
@@ -60416,6 +61088,7 @@ function projectSchemaJsonValue(value) {
 }
 function memberCommon(context, ownerClass, declaration, id2, owner, base) {
   const storage = annotation(declaration.annotations, "storage");
+  const distribution = annotation(declaration.annotations, "distribution");
   const inheritedId = declaration.modifiers.includes("override") || declaration.modifiers.includes("sealed") ? inheritedMemberId(context, ownerClass, declaration.name) : null;
   return {
     id: id2,
@@ -60440,9 +61113,30 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
     overrideOf: inheritedId,
     system: systemMetadata(declaration.annotations),
     storage: storage ? storageValue(storage, "allowed") : declaration.modifiers.includes("readonly") ? base !== void 0 ? base.storage : inheritedId !== null && resolvedMemberStorage(context, inheritedId) === "immutable" ? "immutable" : null : null,
+    distribution: distribution ? distributionValue(distribution, ownerClass, declaration) : null,
     storageKey: storage ? stringArgument(storage, "key") : null
   };
 }
+function distributionValue(value, ownerClass, declaration) {
+  const site = `${ownerClass.name}.${declaration.name}`;
+  if (declaration.kind !== "field") {
+    throw new Error(
+      `@distribution on ${site} is not allowed: a ${declaration.kind} owns no stored value to distribute.`
+    );
+  }
+  const kind = contextualEnumArgument(value, "kind");
+  if (kind === null) {
+    throw new Error(
+      `@distribution on ${site} requires a kind argument, such as @distribution(kind: .Packed).`
+    );
+  }
+  const normalized = kind.toLowerCase();
+  if (normalized === "sparse") return "sparse";
+  if (normalized === "packed") return "packed";
+  throw new Error(
+    `@distribution on ${site} has unknown kind ".${kind}". Valid kinds are .Sparse and .Packed.`
+  );
+}
 function resolvedMemberStorage(context, memberId, visited = /* @__PURE__ */ new Set()) {
   if (visited.has(memberId)) return null;
   visited.add(memberId);
@@ -63179,9 +63873,39 @@ var init_constructor_parameter_settlement = __esm({
 });
 
 // src/project-source/stored-value-placements.ts
+function storedValueRowsByIdV4(records2) {
+  const stored = /* @__PURE__ */ new Map();
+  let packed = false;
+  for (const record3 of records2) {
+    if (record3.deleted === true) continue;
+    if (record3.recordKind !== "value") continue;
+    if (!isObjectRecord2(record3.data)) continue;
+    stored.set(record3.recordId, record3.data);
+    packed ||= rowCarriesPackedValueContent(record3.data);
+  }
+  if (!packed) return stored;
+  const logical = /* @__PURE__ */ new Map();
+  for (const [valueId, row] of stored) {
+    if (!rowCarriesPackedValueContent(row)) {
+      logical.set(valueId, row);
+      continue;
+    }
+    if (!isMemberValue(row)) {
+      throw new PackedValueEncodingError(
+        `Stored value row "${valueId}" packs a child but is not a well-formed value row, so its packed payload cannot be expanded.`
+      );
+    }
+    const decoded = decodePackedValueRow(row);
+    logical.set(valueId, { ...decoded.row });
+    for (const child of decoded.children) {
+      logical.set(child.id, { ...child });
+    }
+  }
+  return logical;
+}
 function buildStoredValuePlacementIndexV4(records2) {
   const live = [...records2].filter((record3) => record3.deleted !== true);
-  const values = /* @__PURE__ */ new Map();
+  const values = storedValueRowsByIdV4(live);
   const classes = [];
   const members = [];
   const memberDataById = /* @__PURE__ */ new Map();
@@ -63189,9 +63913,8 @@ function buildStoredValuePlacementIndexV4(records2) {
   const variantTargetClassByRootValueId = /* @__PURE__ */ new Map();
   for (const record3 of live) {
     if (!isObjectRecord2(record3.data)) continue;
-    if (record3.recordKind === "value") {
-      values.set(record3.recordId, record3.data);
-    } else if (record3.recordKind === "class") {
+    if (record3.recordKind === "value") continue;
+    if (record3.recordKind === "class") {
       classes.push({
         id: record3.recordId,
         ...isStringRecord3(record3.data.schema) ? { schema: record3.data.schema } : {},
@@ -63399,11 +64122,7 @@ function rootValuePathsByValueId(records2, storedPlacements) {
 function rootValueTargetsByPath(records2, storedPlacements) {
   const allRecords = [...records2];
   const paths = rootValuePathsByValueId(allRecords, storedPlacements);
-  const values = new Map(
-    allRecords.flatMap(
-      (record3) => !record3.deleted && record3.recordKind === "value" && isObjectRecord3(record3.data) ? [[record3.recordId, record3.data]] : []
-    )
-  );
+  const values = storedValueRowsByIdV4(allRecords);
   const targets = /* @__PURE__ */ new Map();
   for (const [valueId, path] of paths) {
     const classId = values.get(valueId)?.classId;
@@ -66387,6 +67106,186 @@ function resolveOwnerMembersForValues(document, targetValueIds, additionalRoots,
   }
   return resolved;
 }
+function isStringListValue(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every((entry) => typeof entry === "string");
+}
+function findOwningMembersForValues(document, valueIds, additionalRoots, traversalExtension) {
+  const owners = /* @__PURE__ */ new Map();
+  if (valueIds.size === 0) return owners;
+  const membersById2 = new Map(
+    document.members.map((member) => [member.id, member])
+  );
+  const valuesById = new Map(document.values.map((value) => [value.id, value]));
+  const rowsByContainerId = /* @__PURE__ */ new Map();
+  for (const value of document.values) {
+    if (typeof value.containerId !== "string") continue;
+    const rows = rowsByContainerId.get(value.containerId);
+    if (rows === void 0) {
+      rowsByContainerId.set(value.containerId, [value]);
+    } else {
+      rows.push(value);
+    }
+  }
+  const queue = [];
+  const enqueueClassInstanceChildren = (args) => {
+    const merged = mergeStoredInstanceSchema(
+      args.effectiveClassId,
+      document.classes,
+      document.members
+    );
+    const env = resolveInstanceEnv(
+      args.effectiveClassId,
+      args.member.classArguments,
+      document.classes
+    );
+    for (const entry of merged) {
+      const childValueId = args.record[entry.schemaKey];
+      if (childValueId === void 0) continue;
+      const childMember = membersById2.get(entry.memberId);
+      if (childMember === void 0) continue;
+      queue.push({
+        member: substituteMember(childMember, env, document.members),
+        memberRecordId: childMember.id,
+        id: childValueId,
+        parentValueId: args.parentValueId,
+        // Descending through `Overrides` opens an override graph, and every
+        // row below it stays inside one (D10).
+        insideAnimationOverrideGraph: args.insideAnimationOverrideGraph || entersAnimationOverrideGraph(childMember.id)
+      });
+    }
+  };
+  for (const root of additionalRoots ?? []) {
+    const memberRecordId = getField(root.member, "id");
+    queue.push({
+      member: root.member,
+      memberRecordId: typeof memberRecordId === "string" ? memberRecordId : `semantic:${root.valueId}`,
+      id: root.valueId,
+      insideAnimationOverrideGraph: root.position.insideAnimationOverrideGraph,
+      // A caller-supplied root is a root: it is reached from the caller's own
+      // context, not from a parent row this walk visited.
+      parentValueId: null
+    });
+  }
+  for (const member of document.members) {
+    if (member.valueId !== void 0) {
+      queue.push({
+        member,
+        memberRecordId: member.id,
+        id: member.valueId,
+        // A member-rooted row has no ancestry to have descended through (D10).
+        insideAnimationOverrideGraph: false,
+        parentValueId: null
+      });
+    }
+    const defaultValue = member.defaultValue;
+    if (defaultValue == null) continue;
+    if (!isMemberClassBase(member)) continue;
+    if (!isRecordValue(defaultValue.value)) continue;
+    enqueueClassInstanceChildren({
+      member,
+      record: defaultValue.value,
+      effectiveClassId: defaultValue.classId ?? member.classId,
+      // A declaration default is never itself an override graph (D10).
+      insideAnimationOverrideGraph: false,
+      // The default graph hangs off the MEMBER record, so its children have no
+      // owning value row (P76: they stay physically sparse).
+      parentValueId: null
+    });
+  }
+  const visited = /* @__PURE__ */ new Set();
+  for (let cursor = 0; cursor < queue.length; cursor += 1) {
+    const current = queue[cursor];
+    if (current === void 0) continue;
+    const visitKey = `${current.memberRecordId}:${current.id}`;
+    if (visited.has(visitKey)) continue;
+    visited.add(visitKey);
+    const placement = {
+      member: current.member,
+      position: {
+        insideAnimationOverrideGraph: current.insideAnimationOverrideGraph
+      },
+      parentValueId: current.parentValueId
+    };
+    if (valueIds.has(current.id) && !owners.has(current.id)) {
+      owners.set(current.id, placement);
+      if (owners.size === valueIds.size) return owners;
+    }
+    for (const root of traversalExtension?.({
+      valueId: current.id,
+      placement
+    }) ?? []) {
+      const memberRecordId = getField(root.member, "id");
+      queue.push({
+        member: root.member,
+        memberRecordId: typeof memberRecordId === "string" ? memberRecordId : `semantic:${root.valueId}`,
+        id: root.valueId,
+        insideAnimationOverrideGraph: root.position.insideAnimationOverrideGraph,
+        // A semantic root discovered from this visit is a child of this row —
+        // a settled constructor argument is owned by the row that constructed
+        // it, exactly as a body field is.
+        parentValueId: current.id
+      });
+    }
+    const storedValue = valuesById.get(current.id);
+    if (storedValue === void 0) continue;
+    if (isMemberClassBase(current.member)) {
+      if (!isRecordValue(storedValue.value)) continue;
+      enqueueClassInstanceChildren({
+        member: current.member,
+        record: storedValue.value,
+        effectiveClassId: storedValue.classId ?? current.member.classId,
+        insideAnimationOverrideGraph: current.insideAnimationOverrideGraph,
+        parentValueId: storedValue.id
+      });
+      continue;
+    }
+    if (isMemberDictionaryBase(current.member)) {
+      if (!isRecordValue(storedValue.value)) continue;
+      const entryMemberRecord = membersById2.get(current.member.entryMemberId);
+      if (entryMemberRecord === void 0) continue;
+      const entryMember = substituteMember(
+        entryMemberRecord,
+        envFromStamp(storedValue.genericBindings),
+        document.members
+      );
+      for (const childValueId of Object.values(storedValue.value)) {
+        queue.push({
+          member: entryMember,
+          memberRecordId: entryMemberRecord.id,
+          id: childValueId,
+          // An entry inherits its collection's position: a Dictionary is not
+          // itself a way into an override graph.
+          insideAnimationOverrideGraph: current.insideAnimationOverrideGraph,
+          parentValueId: storedValue.id
+        });
+      }
+      continue;
+    }
+    if (isMemberListBase(current.member)) {
+      const entryMemberRecord = membersById2.get(current.member.entryMemberId);
+      if (entryMemberRecord === void 0) continue;
+      const entryMember = substituteMember(
+        entryMemberRecord,
+        envFromStamp(storedValue.genericBindings),
+        document.members
+      );
+      const childValueIds = listKindOf(current.member) === 1 /* Unordered */ ? (rowsByContainerId.get(storedValue.id) ?? []).map((row) => row.id) : isStringListValue(storedValue.value) ? storedValue.value : [];
+      for (const childValueId of childValueIds) {
+        queue.push({
+          member: entryMember,
+          memberRecordId: entryMemberRecord.id,
+          id: childValueId,
+          // An entry inherits its collection's position: a List is not itself
+          // a way into an override graph.
+          insideAnimationOverrideGraph: current.insideAnimationOverrideGraph,
+          parentValueId: storedValue.id
+        });
+      }
+    }
+  }
+  return owners;
+}
 var init_value_row_owner_members = __esm({
   "../src/database/value-row-owner-members.ts"() {
     "use strict";
@@ -66488,6 +67387,59 @@ function resolveSemanticOwnerMembersForValues(document, targetValueIds, addition
   }
   return result;
 }
+function findSemanticOwnerPlacementsForValues(document, targetValueIds, additionalRoots) {
+  const result = /* @__PURE__ */ new Map();
+  if (targetValueIds.size === 0) return result;
+  const directPlacements = findOwningMembersForValues(
+    document,
+    targetValueIds,
+    additionalRoots
+  );
+  if (directPlacements.size === targetValueIds.size) return directPlacements;
+  const graph = new MaterializedValueGraphContext(document);
+  const allValueIds = new Set(graph.valuesById.keys());
+  const semanticRootIds = /* @__PURE__ */ new Set();
+  const bodyPlacements = findOwningMembersForValues(
+    document,
+    allValueIds,
+    additionalRoots
+  );
+  const placements = findOwningMembersForValues(
+    document,
+    allValueIds,
+    additionalRoots,
+    ({ valueId: ownerValueId, placement: ownerPlacement }) => {
+      const roots = [];
+      for (const edge of graph.edgesByOwnerValueId.get(ownerValueId) ?? []) {
+        if (graph.referenceCountByTargetValueId.get(edge.targetValueId) !== 1) {
+          continue;
+        }
+        if (bodyPlacements.has(edge.targetValueId)) continue;
+        if (semanticRootIds.has(edge.targetValueId)) continue;
+        const member = graph.constructorArgumentOwnerMember(edge);
+        if (member === void 0) continue;
+        const memberId = getField(member, "id");
+        semanticRootIds.add(edge.targetValueId);
+        roots.push({
+          member,
+          valueId: edge.targetValueId,
+          position: {
+            insideAnimationOverrideGraph: ownerPlacement.position.insideAnimationOverrideGraph || typeof memberId === "string" && entersAnimationOverrideGraph(memberId)
+          }
+        });
+      }
+      return roots;
+    }
+  );
+  for (const [valueId, placement] of bodyPlacements) {
+    placements.set(valueId, placement);
+  }
+  for (const valueId of targetValueIds) {
+    const placement = placements.get(valueId);
+    if (placement !== void 0) result.set(valueId, placement);
+  }
+  return result;
+}
 function createTypedValueNormalizer(rows, document, childrenByContainerId, parameterTypesForRow, memberById2, memberTypeInfo, genericEnvironmentForRow) {
   const visiting = /* @__PURE__ */ new Set();
   const normalizeLiteral = (value) => {
@@ -68320,7 +69272,8 @@ var init_project2 = __esm({
 function isCatchableNeoScriptRuntimeError(error) {
   return error instanceof NSGetterRuntimeError && !(error instanceof UncompiledInitializerRuntimeError) && !(error instanceof NonCatchableNSGetterRuntimeError);
 }
-function makeEvaluatorLookups(members, values, options = {}) {
+function makeEvaluatorLookups(members, storedValues, options = {}) {
+  const values = expandPackedValueRows(storedValues);
   const attrMap = /* @__PURE__ */ new Map();
   for (const a of members) attrMap.set(a.id, a);
   const valMap = /* @__PURE__ */ new Map();
@@ -69149,7 +70102,7 @@ function withEvaluationRuntime(ctx, writes) {
     ctx.__runtimeSessionValues
   );
   const referencesAlreadyRemapped = ctx.__valueOverlay !== void 0 && ctx.__runtimeReferenceRemap !== void 0;
-  const remap = (value) => referencesAlreadyRemapped ? value : remapRuntimeReferences(
+  const remap2 = (value) => referencesAlreadyRemapped ? value : remapRuntimeReferences(
     value,
     overlay,
     referenceRemap,
@@ -69157,11 +70110,11 @@ function withEvaluationRuntime(ctx, writes) {
   );
   return {
     ...ctx,
-    thisValue: remap(ctx.thisValue),
-    rootValue: remap(ctx.rootValue),
+    thisValue: remap2(ctx.thisValue),
+    rootValue: remap2(ctx.rootValue),
     dialogueContext: ctx.dialogueContext === void 0 || ctx.dialogueContext === null ? ctx.dialogueContext : {
-      primary: remap(ctx.dialogueContext.primary),
-      trigger: remap(ctx.dialogueContext.trigger)
+      primary: remap2(ctx.dialogueContext.primary),
+      trigger: remap2(ctx.dialogueContext.trigger)
     },
     __runtimeSessionValues: runtimeSessionValues,
     __saveStaticBindings: ctx.__saveStaticBindings ?? staticBindingMap(ctx.saveStaticBindings),
@@ -77156,6 +78109,7 @@ var init_evaluateNSGetter = __esm({
     init_src();
     init_decimal();
     init_members();
+    init_packed_value_encoding();
     init_core();
     init_member_storage_key();
     init_project2();
@@ -78091,12 +79045,6 @@ function resolveVirtualInstanceGraph(args) {
     };
     rowsById.set(effectiveId, effective);
     locationsById.set(effectiveId, location3);
-    if (effectiveId !== indexed.virtualId) {
-      locationsById.set(indexed.virtualId, {
-        ...location3,
-        id: indexed.virtualId
-      });
-    }
     locationsByPath.set(pathKey, location3);
     visiting.delete(pathKey);
     return location3;
@@ -78150,10 +79098,9 @@ function reportFrameResolutionDisagreement(args) {
   );
 }
 function resolvedStoredInstanceRows(args) {
-  const rows = new Map(args.document.values.map((row) => [row.id, row]));
-  const materializedIndex = buildVirtualInstanceMaterializedIndex({
-    document: args.document
-  });
+  const document = expandPackedDocumentValues(args.document);
+  const rows = new Map(document.values.map((row) => [row.id, row]));
+  const materializedIndex = buildVirtualInstanceMaterializedIndex({ document });
   const queue = [{ root: args.instanceRoot, member: args.rootMember }];
   const resolvedRootIds = /* @__PURE__ */ new Set();
   const resolvedFrameByValueId = /* @__PURE__ */ new Map();
@@ -78162,12 +79109,12 @@ function resolvedStoredInstanceRows(args) {
     if (next === void 0 || resolvedRootIds.has(next.root.id)) continue;
     resolvedRootIds.add(next.root.id);
     const expanded = expandStoredInstance({
-      document: args.document,
+      document,
       instanceRoot: next.root,
       rootMember: next.member
     });
     const graph = resolveVirtualInstanceGraph({
-      document: args.document,
+      document,
       instanceRoot: next.root,
       rootMember: next.member,
       expandedRoot: expanded.root,
@@ -78829,12 +79776,12 @@ function sparsifyConstructedInstance(args) {
       ) ?? virtualId
     );
   }
-  const remap = (value) => {
+  const remap2 = (value) => {
     if (typeof value === "string") return nextIdById.get(value) ?? value;
-    if (Array.isArray(value)) return value.map(remap);
+    if (Array.isArray(value)) return value.map(remap2);
     if (typeof value !== "object" || value === null) return value;
     return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [key, remap(entry)])
+      Object.entries(value).map(([key, entry]) => [key, remap2(entry)])
     );
   };
   const rewrite = (row) => {
@@ -78842,9 +79789,9 @@ function sparsifyConstructedInstance(args) {
     return {
       ...literal2,
       id: nextIdById.get(row.id) ?? row.id,
-      value: remap(updatedValueById.get(row.id) ?? literal2.value),
+      value: remap2(updatedValueById.get(row.id) ?? literal2.value),
       ...literal2.constructorArgs === void 0 ? {} : {
-        constructorArgs: remap(literal2.constructorArgs)
+        constructorArgs: remap2(literal2.constructorArgs)
       },
       ...typeof row.containerId === "string" ? { containerId: nextIdById.get(row.containerId) ?? row.containerId } : {}
     };
@@ -79699,6 +80646,7 @@ var init_virtual_instance_values = __esm({
     init_classes();
     init_members();
     init_member_value_id();
+    init_packed_value_encoding();
     init_stored_value_placement_index();
     init_instance_provenance();
     init_unordered_list_membership();
@@ -80432,6 +81380,16 @@ var init_projectRecordBuckets = __esm({
 });
 
 // ../src/database/project-record-migrations.ts
+function migrateValueDataV1ToV2(data) {
+  if (typeof data !== "object" || data === null) return data;
+  const value = Reflect.get(data, "value");
+  if (typeof value !== "object" || value === null) return data;
+  if (!Object.hasOwn(value, PACKED_VALUE_ENTRY_KEY)) return data;
+  const id2 = Reflect.get(data, "id");
+  throw new Error(
+    `Value "${typeof id2 === "string" ? id2 : "<unknown>"}" is stamped data schema version 1 but its body already carries a "${PACKED_VALUE_ENTRY_KEY}" envelope; only version 2 may pack a subtree.`
+  );
+}
 function migrateProjectRecordData(args) {
   const currentVersion = CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION[args.recordKind];
   if (args.dataSchemaVersion > currentVersion) {
@@ -80455,11 +81413,26 @@ var CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION, PROJECT_RECORD_DATA_MIGRATIONS;
 var init_project_record_migrations = __esm({
   "../src/database/project-record-migrations.ts"() {
     "use strict";
+    init_packed_value_encoding();
     init_project2();
     CURRENT_PROJECT_RECORD_DATA_SCHEMA_VERSION = {
       [ProjectRecordKind.Project]: 1,
       [ProjectRecordKind.Member]: 6,
-      [ProjectRecordKind.Value]: 1,
+      /**
+       * 2 — P76 §3.1. A value body may carry `~packed` envelopes, so a v1 reader
+       * would hand a packed child's envelope to an evaluator as if it were the
+       * child's value, and an external reader has to fail closed on v2 (spec
+       * §"Goals": "old readers fail closed").
+       *
+       * The 1 -> 2 rung below is load-bearing rather than optional. The P76
+       * migrations are themselves ordinary writers: they read a value's base
+       * record through {@link migrateProjectRecordData} before they can write it.
+       * Bumping this with an empty ladder makes every stored v1 value unreadable
+       * by the very sweep that is supposed to advance it, which is circular. The
+       * rung breaks that circle, and retires with the migration once the corpus
+       * carries no v1 value.
+       */
+      [ProjectRecordKind.Value]: 2,
       [ProjectRecordKind.Class]: 2,
       [ProjectRecordKind.Constructor]: 1,
       [ProjectRecordKind.Variant]: 1,
@@ -80482,7 +81455,7 @@ var init_project_record_migrations = __esm({
     PROJECT_RECORD_DATA_MIGRATIONS = {
       [ProjectRecordKind.Project]: {},
       [ProjectRecordKind.Member]: {},
-      [ProjectRecordKind.Value]: {},
+      [ProjectRecordKind.Value]: { 1: migrateValueDataV1ToV2 },
       [ProjectRecordKind.Class]: {},
       [ProjectRecordKind.Constructor]: {},
       [ProjectRecordKind.Variant]: {},
@@ -80511,7 +81484,9 @@ __export(project_document_read_exports, {
   DOCUMENT_MANIFEST_PAGE_SIZE: () => DOCUMENT_MANIFEST_PAGE_SIZE,
   DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE: () => DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE,
   DOCUMENT_SNAPSHOT_FETCH_CONCURRENCY: () => DOCUMENT_SNAPSHOT_FETCH_CONCURRENCY,
+  appendProjectRecordToBuckets: () => appendProjectRecordToBuckets,
   assembleProjectDocumentRaw: () => assembleProjectDocumentRaw,
+  emptyProjectRecordBuckets: () => emptyProjectRecordBuckets,
   fetchProjectDocumentPartitionRecords: () => fetchProjectDocumentPartitionRecords,
   fetchProjectDocumentRawChunked: () => fetchProjectDocumentRawChunked,
   fetchProjectDocumentSnapshots: () => fetchProjectDocumentSnapshots,
@@ -80522,7 +81497,8 @@ __export(project_document_read_exports, {
   readProjectDocumentContentHashHeads: () => readProjectDocumentContentHashHeads,
   readProjectDocumentManifestPageRecords: () => readProjectDocumentManifestPageRecords,
   readProjectDocumentManifestRecords: () => readProjectDocumentManifestRecords,
-  readProjectDocumentRevisionMarker: () => readProjectDocumentRevisionMarker
+  readProjectDocumentRevisionMarker: () => readProjectDocumentRevisionMarker,
+  readStoredMembersField: () => readStoredMembersField
 });
 async function fetchProjectDocumentRawChunked(runner, options = {}) {
   const mapKeys = options.mapKeys ?? [
@@ -80847,29 +81823,7 @@ function readProjectDocumentSnapshotBatch(value, requestedIds) {
   });
 }
 function assembleProjectDocumentRaw(args) {
-  const buckets = {
-    project: null,
-    members: [],
-    classes: [],
-    constructors: [],
-    variants: [],
-    variantFolders: [],
-    internalRecordRelations: [],
-    values: [],
-    enums: [],
-    interfaces: [],
-    dialogueRecords: [],
-    dialogueNodes: [],
-    dialogueGroups: [],
-    priorityGroups: [],
-    projectFiles: [],
-    textureTemplates: [],
-    audioClipTemplates: [],
-    localizationConfig: null,
-    localizationStatuses: [],
-    localizedTexts: [],
-    migrations: []
-  };
+  const buckets = emptyProjectRecordBuckets();
   const contentHashHeads = [];
   const sortedRecords = [...args.records].sort((left, right) => {
     const kind = left.recordKind.localeCompare(right.recordKind);
@@ -80898,7 +81852,7 @@ function assembleProjectDocumentRaw(args) {
         `Convex project document manifest references deleted snapshot "${snapshot.id}" for live record "${record3.recordId}".`
       );
     }
-    appendBucketRecord(buckets, record3.recordKind, snapshot.data);
+    appendProjectRecordToBuckets(buckets, record3.recordKind, snapshot.data);
     contentHashHeads.push({
       recordKind: record3.recordKind,
       recordId: record3.recordId,
@@ -80944,7 +81898,32 @@ function assembleProjectDocumentRaw(args) {
   }
   return document;
 }
-function appendBucketRecord(buckets, recordKind, data) {
+function emptyProjectRecordBuckets() {
+  return {
+    project: null,
+    members: [],
+    classes: [],
+    constructors: [],
+    variants: [],
+    variantFolders: [],
+    internalRecordRelations: [],
+    values: [],
+    enums: [],
+    interfaces: [],
+    dialogueRecords: [],
+    dialogueNodes: [],
+    dialogueGroups: [],
+    priorityGroups: [],
+    projectFiles: [],
+    textureTemplates: [],
+    audioClipTemplates: [],
+    localizationConfig: null,
+    localizationStatuses: [],
+    localizedTexts: [],
+    migrations: []
+  };
+}
+function appendProjectRecordToBuckets(buckets, recordKind, data) {
   const bucket = PROJECT_RECORD_BUCKETS[recordKind];
   if (bucket === "project") {
     if (buckets.project !== null) {
@@ -80966,6 +81945,11 @@ function appendBucketRecord(buckets, recordKind, data) {
   }
   buckets[bucket].push(data);
 }
+function projectDocumentValueBuckets(rows) {
+  const expanded = expandPackedValueRows(rows);
+  if (expanded === rows) return { values: rows };
+  return { values: [...expanded], physicalValues: rows };
+}
 function readProjectDocument(value, options = {}) {
   if (!isObject4(value)) {
     throw new Error("Convex project document query returned a non-object.");
@@ -80975,6 +81959,9 @@ function readProjectDocument(value, options = {}) {
     "localizationConfig",
     isProjectLocalizationConfig
   ) : readField(value, "localizationConfig", isProjectLocalizationConfig);
+  const valueBuckets = projectDocumentValueBuckets(
+    readArrayField(value, "values", isMemberValue)
+  );
   return {
     version: readField(value, "version", isProjectVersion),
     versions: readArrayField(value, "versions", isProjectVersion),
@@ -80990,12 +81977,8 @@ function readProjectDocument(value, options = {}) {
       isProjectReleaseChannel
     ),
     project: readField(value, "project", isProject),
-    // Stored override rows are intentionally sparse. Narrow with the canonical
-    // storage union at this wire boundary while preserving the document's
-    // member collection type.
-    members: readArrayField(
+    members: readStoredMembersField(
       value,
-      "members",
       options.members === "authored-or-compiled" ? isAnyMemberAuthoredOrCompiled : isAnyMember
     ),
     classes: readArrayField(value, "classes", isNeoSchemaClass),
@@ -81015,7 +81998,13 @@ function readProjectDocument(value, options = {}) {
       "internalRecordRelations",
       isInternalRecordRelation
     ),
-    values: readArrayField(value, "values", isMemberValue),
+    // P76: a document is a READ model, so its `values` bucket is the logical
+    // row set — packed parents holding plain child-id strings, packed children
+    // as rows of their own. The physical form stays in the record stream this
+    // document was built from, which is what the CLI's merge base and CAS
+    // compare; nothing round-trips a document bucket back into storage.
+    values: valueBuckets.values,
+    ...valueBuckets.physicalValues === void 0 ? {} : { physicalValues: valueBuckets.physicalValues },
     enums: readArrayField(
       value,
       "enums",
@@ -81110,6 +82099,13 @@ function readOptionalArrayField(source, key, isValid) {
   if (!Object.prototype.hasOwnProperty.call(source, key)) return [];
   return readArrayField(source, key, isValid);
 }
+function readStoredMembersField(source, isValid = isAnyMember) {
+  return readArrayField(
+    source,
+    "members",
+    isValid
+  );
+}
 function isObject4(value) {
   if (typeof value !== "object") return false;
   return value !== null;
@@ -81136,6 +82132,7 @@ var init_project_document_read = __esm({
     "use strict";
     init_project2();
     init_members();
+    init_packed_value_encoding();
     init_classes();
     init_constructors2();
     init_variants2();
@@ -86547,322 +87544,53 @@ var init_animation_clips = __esm({
   }
 });
 
-// ../src/database/headless-virtual-instance-lookups.ts
-function headlessVirtualInstanceLookups(document, options = {}) {
-  const members = document.members;
-  const values = document.values;
-  const indexed = makeEvaluatorLookups(
-    members,
-    values,
-    options.includeValueGraphIndexes === true ? {
-      includeValueGraphIndexes: true,
-      constructorInitializerDocument: {
-        classes: document.classes,
-        members,
-        values
-      }
-    } : {}
-  );
-  const virtual = createHeadlessVirtualInstanceResolver({
-    document: {
-      ...document,
-      ...options.initializerCompiler === void 0 ? {} : { initializerCompiler: options.initializerCompiler }
-    },
-    // A thunk: the resolver resolves nested reads through the lookups being
-    // built around it.
-    resolverLookups: () => lookups
-  });
-  const lookups = {
-    ...indexed,
-    // Raw first, then virtual: a materialized row always wins over the
-    // expansion that would otherwise answer for it.
-    valueById: (id2) => indexed.valueById(id2) ?? virtual.valueById(id2),
-    rowForValueReference: (value) => indexed.rowForValueReference(value) ?? virtual.rowForValueReference(value),
-    virtualInstanceRowsForValue: (receiverValueId) => virtual.virtualInstanceRowsForValue(receiverValueId),
-    // Stored-construction replay evaluates `ToVariant`, and production's
-    // variant-constructed placements collapse through exactly this path.
-    resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
-      document,
-      resolverLookups: lookups,
-      ...args
-    }),
-    // A write to a virtual key must MATERIALIZE it (a pin row at the
-    // deterministic virtual id plus the sparse spine); the planner needs the
-    // owning graph, not just its rows.
-    virtualInstanceGraphForValue: (valueId) => virtual.virtualInstanceGraphForValue(valueId)
-  };
-  return lookups;
-}
-var init_headless_virtual_instance_lookups = __esm({
-  "../src/database/headless-virtual-instance-lookups.ts"() {
-    "use strict";
-    init_virtual_instance_values();
-    init_neoscript_evaluator();
-  }
-});
-
-// src/evaluator-lookups.ts
-function cliEvaluatorLookups(document, options = {}) {
-  return cliEvaluatorRuntime(document, options).databaseVM;
-}
-function cliEvaluatorRuntime(document, options = {}) {
-  const initializerCompiler = isPulledInitializerCompilationDocumentV4(document) ? pulledInitializerCompilerV4(document) : void 0;
-  const databaseVM = headlessVirtualInstanceLookups(document, {
-    ...options,
-    ...initializerCompiler === void 0 ? {} : { initializerCompiler }
-  });
-  return {
-    databaseVM,
-    ...initializerCompiler === void 0 ? {} : { initializerCompiler }
-  };
-}
-function cliEvaluatorReceiverValue(lookups, valueId) {
-  if (typeof valueId !== "string") return null;
-  return lookups.valueById(valueId)?.value ?? null;
+// ../src/database/canonical-json.ts
+function canonicalJsonStringify(value) {
+  return JSON.stringify(toCanonicalJsonValue(value));
 }
-var init_evaluator_lookups = __esm({
-  "src/evaluator-lookups.ts"() {
-    "use strict";
-    init_headless_virtual_instance_lookups();
-    init_initializer_replay();
-  }
-});
-
-// src/project-source/materialized-construction-cache.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { createHash as createHash3 } from "node:crypto";
-import { dirname as dirname2, join as join3 } from "node:path";
-function createMaterializedConstructionExpressionsV1(args) {
-  const warm = args.useBuildCaches ? readMaterializedConstructionBuildCacheV2(args.root, args.state) : null;
-  const emitted = /* @__PURE__ */ new Map();
-  const overrideKeys = /* @__PURE__ */ new Map();
-  let emitters;
-  return {
-    get(valueId) {
-      const cached = warm?.expressions.get(valueId);
-      if (cached !== void 0) return cached;
-      if (emitted.has(valueId)) return emitted.get(valueId);
-      emitters ??= storedConstructionEmitters(args.state, args.manifest);
-      const expression = emitters.construction(valueId);
-      emitted.set(valueId, expression);
-      return expression;
-    },
-    overrideSchemaKeys(valueId) {
-      const cached = warm?.overrideKeys.get(valueId);
-      if (cached !== void 0) return cached;
-      if (overrideKeys.has(valueId)) return overrideKeys.get(valueId);
-      emitters ??= storedConstructionEmitters(args.state, args.manifest);
-      const keys = emitters.overrideSchemaKeys(valueId);
-      overrideKeys.set(valueId, keys);
-      return keys;
-    }
-  };
+function canonicallyEqual2(left, right) {
+  return canonicalJsonStringify(left) === canonicalJsonStringify(right);
 }
-function storedConstructionEmitters(state, manifest) {
-  const records2 = /* @__PURE__ */ new Map();
-  const candidateRoots = /* @__PURE__ */ new Set();
-  for (const record3 of Object.values(state.records)) {
-    records2.set(`${record3.recordKind}:${record3.recordId}`, {
-      recordKind: record3.recordKind,
-      recordId: record3.recordId,
-      contentHash: record3.contentHash,
-      deleted: false,
-      data: record3.data
-    });
-    if (record3.recordKind !== "value") continue;
-    if (!isObjectRecord2(record3.data)) continue;
-    if (!isObjectRecord2(record3.data.value)) continue;
-    const constructorArgs = record3.data.constructorArgs;
-    const hasInstanceProvenance = carriesStoredInstanceProvenance(record3.data);
-    if (constructorArgs !== void 0 && constructorArgs !== null && !hasInstanceProvenance) {
-      continue;
-    }
-    candidateRoots.add(record3.recordId);
-  }
-  const document = readPulledProjectDocumentV4(records2);
-  const owners = resolveOwnerMembersForValues(document, candidateRoots);
-  const storedPlacements = buildStoredValuePlacementIndexV4(records2.values());
-  const membersById2 = new Map(
-    document.members.map((member) => [member.id, member])
-  );
-  for (const valueId of candidateRoots) {
-    if (owners.has(valueId)) continue;
-    const memberId = storedPlacements.placementByChildValueId.get(valueId)?.memberId;
-    const member = memberId === null || memberId === void 0 ? void 0 : membersById2.get(memberId);
-    if (member !== void 0) owners.set(valueId, member);
-  }
-  const probe = createStoredConstructionProbeV4(records2, manifest);
-  let parents;
-  const parentByChildId = () => parents ??= storedValueParentIndex(records2, storedPlacements);
-  const root = (valueId) => {
-    const member = owners.get(valueId);
-    return member === void 0 ? void 0 : {
-      member,
-      valueId
-    };
-  };
-  const probedRootIds = /* @__PURE__ */ new Set();
-  const probeRootOnce = (rootValueId, ownedRoot) => {
-    if (probedRootIds.has(rootValueId)) {
-      return /* @__PURE__ */ new Set();
-    }
-    probedRootIds.add(rootValueId);
-    return probe.overrideKeys(ownedRoot);
-  };
-  return {
-    construction(valueId) {
-      const ownedRoot = root(valueId);
-      if (ownedRoot === void 0) return void 0;
-      return probe.construction(ownedRoot);
-    },
-    overrideSchemaKeys(valueId) {
-      const recorded = probe.overrideKeysOf(valueId);
-      if (recorded !== void 0) return recorded;
-      const ownedRoot = root(valueId);
-      if (ownedRoot !== void 0) return probeRootOnce(valueId, ownedRoot);
-      const ancestor = nearestOwnedAncestor(valueId, parentByChildId(), owners);
-      if (ancestor === null) return void 0;
-      const ancestorRoot = root(ancestor);
-      if (ancestorRoot === void 0) return void 0;
-      if (probedRootIds.has(ancestor)) return void 0;
-      probeRootOnce(ancestor, ancestorRoot);
-      return probe.overrideKeysOf(valueId);
+function toCanonicalJsonValue(value) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Cannot canonicalize a non-finite number.");
     }
-  };
-}
-function storedValueParentIndex(records2, placements) {
-  const parents = /* @__PURE__ */ new Map();
-  const valueIds = /* @__PURE__ */ new Set();
-  for (const record3 of records2.values()) {
-    if (record3.recordKind === "value") valueIds.add(record3.recordId);
+    return value;
   }
-  for (const record3 of records2.values()) {
-    if (record3.recordKind !== "value") continue;
-    if (!isObjectRecord2(record3.data)) continue;
-    const containerId = record3.data.containerId;
-    if (typeof containerId === "string" && valueIds.has(containerId)) {
-      parents.set(record3.recordId, containerId);
-    }
-    const body = record3.data.value;
-    if (Array.isArray(body)) {
-      for (const entry of body) {
-        if (typeof entry === "string" && valueIds.has(entry)) {
-          parents.set(entry, record3.recordId);
-        }
-      }
-      continue;
-    }
-    if (!isObjectRecord2(body)) continue;
-    for (const child of Object.values(body)) {
-      if (typeof child === "string" && valueIds.has(child)) {
-        parents.set(child, record3.recordId);
-      }
-    }
+  if (typeof value === "bigint") {
+    throw new Error("Cannot canonicalize bigint values.");
   }
-  for (const edge of placements.placementByChildValueId.values()) {
-    if (edge.source !== "constructor") continue;
-    if (!parents.has(edge.childValueId)) {
-      parents.set(edge.childValueId, edge.parentValueId);
-    }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot canonicalize symbol values.");
   }
-  return parents;
-}
-function nearestOwnedAncestor(valueId, parents, owners) {
-  const seen = /* @__PURE__ */ new Set([valueId]);
-  let cursor = parents.get(valueId);
-  while (cursor !== void 0 && !seen.has(cursor)) {
-    if (owners.has(cursor)) return cursor;
-    seen.add(cursor);
-    cursor = parents.get(cursor);
+  if (typeof value === "function") {
+    throw new Error("Cannot canonicalize function values.");
   }
-  return null;
-}
-function carriesStoredInstanceProvenance(value) {
-  return isVirtualInstanceRootShape(value);
-}
-function readMaterializedConstructionBuildCacheV2(root, state) {
-  try {
-    const parsed = JSON.parse(
-      readFileSync3(
-        join3(root, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH),
-        "utf8"
-      )
-    );
-    if (parsed === null || typeof parsed !== "object") return null;
-    const cache = parsed;
-    if (cache.revision !== MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION || cache.stateFingerprint !== materializedConstructionStateFingerprint(state) || cache.expressions === null || typeof cache.expressions !== "object" || Array.isArray(cache.expressions)) {
-      return null;
-    }
-    const expressions = /* @__PURE__ */ new Map();
-    for (const [valueId, expression] of Object.entries(cache.expressions)) {
-      if (typeof expression !== "string") return null;
-      expressions.set(valueId, expression);
-    }
-    const overrideKeys = /* @__PURE__ */ new Map();
-    if (cache.overrideKeys !== void 0) {
-      if (cache.overrideKeys === null || typeof cache.overrideKeys !== "object" || Array.isArray(cache.overrideKeys)) {
-        return null;
-      }
-      for (const [valueId, keys] of Object.entries(cache.overrideKeys)) {
-        if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) {
-          return null;
-        }
-        overrideKeys.set(valueId, new Set(keys));
-      }
-    }
-    return { expressions, overrideKeys };
-  } catch {
-    return null;
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      const canonicalItem = toCanonicalJsonValue(item);
+      if (canonicalItem === void 0) return null;
+      return canonicalItem;
+    });
   }
-}
-function writeMaterializedConstructionBuildCacheV2(root, state, cache) {
-  const file = join3(root, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH);
-  mkdirSync3(dirname2(file), { recursive: true });
-  const temporary = `${file}.${process.pid}.tmp`;
-  writeFileSync3(
-    temporary,
-    `${JSON.stringify({
-      revision: MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION,
-      stateFingerprint: materializedConstructionStateFingerprint(state),
-      expressions: Object.fromEntries(
-        [...cache.expressions].sort(
-          ([left], [right]) => left.localeCompare(right)
-        )
-      ),
-      overrideKeys: Object.fromEntries(
-        [...cache.overrideKeys ?? /* @__PURE__ */ new Map()].sort(([left], [right]) => left.localeCompare(right)).map(([valueId, keys]) => [valueId, [...keys].sort()])
-      )
-    })}
-`,
-    "utf8"
-  );
-  renameSync(temporary, file);
-}
-function materializedConstructionStateFingerprint(state) {
-  const hash = createHash3("sha256");
-  hash.update(String(MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION));
-  for (const [key, record3] of Object.entries(state.records).sort(
-    ([left], [right]) => left.localeCompare(right)
-  )) {
-    hash.update("\0");
-    hash.update(key);
-    hash.update("\0");
-    hash.update(record3.contentHash);
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  const canonicalObject = {};
+  for (const [key, entryValue] of entries) {
+    const canonicalValue = toCanonicalJsonValue(entryValue);
+    if (canonicalValue === void 0) continue;
+    canonicalObject[key] = canonicalValue;
   }
-  return hash.digest("hex");
+  return canonicalObject;
 }
-var MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION;
-var init_materialized_construction_cache = __esm({
-  "src/project-source/materialized-construction-cache.ts"() {
+var init_canonical_json = __esm({
+  "../src/database/canonical-json.ts"() {
     "use strict";
-    init_projection();
-    init_initializer_replay();
-    init_value_row_owner_members();
-    init_instance_provenance();
-    init_value_sources();
-    init_stored_value_placements();
-    MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH = ".neo/build/materialized-constructions-v1.json";
-    MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION = 2;
   }
 });
 
@@ -87049,6 +87777,22 @@ function collectVariantGraphValueIds(args) {
   }
   return collected;
 }
+function withVariantPlacementRoots(document) {
+  const variants = document.variants ?? [];
+  if (variants.length === 0) {
+    return { document, roots: NO_PLACEMENT_ROOTS };
+  }
+  const scope = withVariantOwnershipRoots(document, variants);
+  return {
+    document: scope.document,
+    roots: scope.roots.map((root) => ({
+      member: root.member,
+      valueId: root.valueId,
+      position: VARIANT_ROOT_POSITION
+    }))
+  };
+}
+var NO_PLACEMENT_ROOTS, VARIANT_ROOT_POSITION;
 var init_variant_value_graph = __esm({
   "../src/database/variant-value-graph.ts"() {
     "use strict";
@@ -87056,56 +87800,958 @@ var init_variant_value_graph = __esm({
     init_classes();
     init_core();
     init_constructor_argument_ownership();
+    NO_PLACEMENT_ROOTS = [];
+    VARIANT_ROOT_POSITION = {
+      insideAnimationOverrideGraph: false
+    };
   }
 });
 
-// ../src/database/canonical-json.ts
-function canonicalJsonStringify(value) {
-  return JSON.stringify(toCanonicalJsonValue(value));
+// ../src/database/project-version-intents.ts
+function createProjectVersionIntent(type, details) {
+  if (details === void 0) {
+    return {
+      type,
+      schemaVersion: PROJECT_VERSION_INTENT_SCHEMA_VERSION
+    };
+  }
+  return {
+    type,
+    schemaVersion: PROJECT_VERSION_INTENT_SCHEMA_VERSION,
+    details
+  };
 }
-function canonicallyEqual2(left, right) {
+function isKnownProjectVersionIntentType(value) {
+  return Object.values(ProjectVersionIntentType).includes(
+    value
+  );
+}
+var ProjectVersionIntentType, PROJECT_VERSION_INTENT_SCHEMA_VERSION;
+var init_project_version_intents = __esm({
+  "../src/database/project-version-intents.ts"() {
+    "use strict";
+    ProjectVersionIntentType = {
+      ProjectCreate: "project.create",
+      ProjectUpdate: "project.update",
+      MemberCreate: "member.create",
+      MemberUpdate: "member.update",
+      MemberRename: "member.rename",
+      MemberSetValue: "member.set-value",
+      MemberClearValue: "member.clear-value",
+      MemberDelete: "member.delete",
+      ClassCreate: "class.create",
+      ClassUpdate: "class.update",
+      ClassDelete: "class.delete",
+      ClassAddSchemaEntry: "class.add-schema-entry",
+      ConstructorCreate: "constructor.create",
+      ConstructorUpdate: "constructor.update",
+      ConstructorDelete: "constructor.delete",
+      VariantCreate: "variant.create",
+      VariantUpdate: "variant.update",
+      VariantDelete: "variant.delete",
+      VariantFolderCreate: "variant-folder.create",
+      VariantFolderUpdate: "variant-folder.update",
+      VariantFolderDelete: "variant-folder.delete",
+      InternalRecordRelationCreate: "internal-record-relation.create",
+      InternalRecordRelationUpdate: "internal-record-relation.update",
+      InternalRecordRelationDelete: "internal-record-relation.delete",
+      EnumCreate: "enum.create",
+      EnumUpdate: "enum.update",
+      EnumDelete: "enum.delete",
+      InterfaceCreate: "interface.create",
+      InterfaceUpdate: "interface.update",
+      InterfaceDelete: "interface.delete",
+      EnumOptionRename: "enum-option.rename",
+      EnumOptionDelete: "enum-option.delete",
+      ValueCreate: "value.create",
+      ValueUpdate: "value.update",
+      /** P76 §3: a row rewritten only because its member's distribution moved. */
+      ValueRedistribute: "value.redistribute",
+      ValueDelete: "value.delete",
+      ValueEntryRenameKey: "value-entry.rename-key",
+      DialogueCreate: "dialogue.create",
+      DialogueUpdate: "dialogue.update",
+      DialogueDelete: "dialogue.delete",
+      DialogueNodeCreate: "dialogue-node.create",
+      DialogueNodeUpdate: "dialogue-node.update",
+      DialogueNodeDelete: "dialogue-node.delete",
+      DialogueGroupCreate: "dialogue-group.create",
+      DialogueGroupUpdate: "dialogue-group.update",
+      DialogueGroupDelete: "dialogue-group.delete",
+      PriorityGroupCreate: "priority-group.create",
+      PriorityGroupUpdate: "priority-group.update",
+      PriorityGroupDelete: "priority-group.delete",
+      ProjectFileCreate: "project-file.create",
+      ProjectFileUpdate: "project-file.update",
+      ProjectFileDelete: "project-file.delete",
+      UnityTextureTemplateCreate: "unity-texture-template.create",
+      UnityTextureTemplateUpdate: "unity-texture-template.update",
+      UnityTextureTemplateDelete: "unity-texture-template.delete",
+      UnityAudioClipTemplateCreate: "unity-audio-clip-template.create",
+      UnityAudioClipTemplateUpdate: "unity-audio-clip-template.update",
+      UnityAudioClipTemplateDelete: "unity-audio-clip-template.delete",
+      LocalizationConfigCreate: "localization-config.create",
+      LocalizationConfigUpdate: "localization-config.update",
+      LocalizationStatusCreate: "localization-status.create",
+      LocalizationStatusUpdate: "localization-status.update",
+      LocalizationStatusDelete: "localization-status.delete",
+      LocalizedTextCreate: "localized-text.create",
+      LocalizedTextUpdate: "localized-text.update",
+      LocalizedTextDelete: "localized-text.delete",
+      MigrationCreate: "migration.create",
+      MigrationUpdate: "migration.update",
+      MigrationDelete: "migration.delete"
+    };
+    PROJECT_VERSION_INTENT_SCHEMA_VERSION = 1;
+  }
+});
+
+// ../src/database/packed-value-write-fold.ts
+function schemaPacksAnyMember(members) {
+  const cached = packedSchemaCache.get(members);
+  if (cached !== void 0) return cached;
+  let packs = false;
+  for (const member of members) {
+    if (effectiveMemberDistribution(member, members) !== 1 /* Packed */) {
+      continue;
+    }
+    packs = true;
+    break;
+  }
+  packedSchemaCache.set(members, packs);
+  return packs;
+}
+function packableParentValueId(args) {
+  if (args.placement.parentValueId === null) return null;
+  if (args.row.containerId !== void 0) return null;
+  if (args.parentRow === void 0) return null;
+  if (args.parentRow.mapKey !== args.row.mapKey) return null;
+  return args.placement.parentValueId;
+}
+function packedChildPlacement(args) {
+  const placement = args.placement;
+  if (placement === void 0) return null;
+  const parentValueId = packableParentValueId({ ...args, placement });
+  if (parentValueId === null) return null;
+  if (effectiveMemberDistribution(placement.member, args.members) !== 1 /* Packed */) {
+    return null;
+  }
+  return parentValueId;
+}
+function foldPackedValueRows(args) {
+  const expanded = args.residency === void 0 ? expandWithResidency(args.rows) : { ...args.residency, logicalRows: args.rows };
+  if (expanded.rootByPackedId.size === 0 && !schemaPacksAnyMember(args.document.members)) {
+    return { rows: args.rows, rootByFoldedId: NO_FOLDED_IDS };
+  }
+  const rowsById = /* @__PURE__ */ new Map();
+  for (const row of expanded.logicalRows) rowsById.set(row.id, row);
+  const scope = withVariantPlacementRoots({
+    ...args.document,
+    values: [...expanded.logicalRows]
+  });
+  const placements = findSemanticOwnerPlacementsForValues(
+    scope.document,
+    new Set(rowsById.keys()),
+    scope.roots
+  );
+  const parentByPackedId = /* @__PURE__ */ new Map();
+  for (const row of expanded.logicalRows) {
+    const placement = placements.get(row.id);
+    const parentValueId = packedChildPlacement({
+      row,
+      placement,
+      parentRow: placement?.parentValueId == null ? void 0 : rowsById.get(placement.parentValueId),
+      members: args.document.members
+    });
+    if (parentValueId !== null) {
+      parentByPackedId.set(row.id, parentValueId);
+      continue;
+    }
+    const residentParent = expanded.parentByPackedId.get(row.id);
+    if (residentParent === void 0) continue;
+    const residentParentRow = rowsById.get(residentParent);
+    if (residentParentRow === void 0) continue;
+    if (!rowNamesChild(residentParentRow, row.id)) continue;
+    parentByPackedId.set(row.id, residentParent);
+  }
+  if (parentByPackedId.size === 0) {
+    return { rows: args.rows, rootByFoldedId: NO_FOLDED_IDS };
+  }
+  const rootByFoldedId = /* @__PURE__ */ new Map();
+  const packedChildIdsByParentId = /* @__PURE__ */ new Map();
+  for (const [childId, parentId] of parentByPackedId) {
+    const siblings = packedChildIdsByParentId.get(parentId);
+    if (siblings === void 0) {
+      packedChildIdsByParentId.set(parentId, [childId]);
+    } else {
+      siblings.push(childId);
+    }
+    rootByFoldedId.set(childId, distributionRootOf(childId, parentByPackedId));
+  }
+  const encodeRootIds = args.encodeOnlyRootIds?.(rootByFoldedId);
+  const rows = [];
+  for (const row of expanded.logicalRows) {
+    if (parentByPackedId.has(row.id)) continue;
+    if (!packedChildIdsByParentId.has(row.id)) {
+      rows.push(row);
+      continue;
+    }
+    if (encodeRootIds !== void 0 && !encodeRootIds.has(row.id)) {
+      rows.push(row);
+      continue;
+    }
+    rows.push(
+      encodePackedValueRow({ parent: row, rowsById, packedChildIdsByParentId })
+    );
+  }
+  return { rows, rootByFoldedId };
+}
+function distributionRootOf(childId, parentByPackedId) {
+  let current = childId;
+  for (let step = 0; step < PACKED_ANCESTOR_LIMIT; step += 1) {
+    const parent = parentByPackedId.get(current);
+    if (parent === void 0) return current;
+    current = parent;
+  }
+  throw new PackedValueEncodingError(
+    `Packed value "${childId}" has more than ${PACKED_ANCESTOR_LIMIT} packed ancestors, so its distribution root cannot be resolved.`
+  );
+}
+function expandWithResidency(rows) {
+  let firstPacked = -1;
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === void 0 || !rowCarriesPackedValueContent(row)) continue;
+    firstPacked = index;
+    break;
+  }
+  if (firstPacked < 0) {
+    return {
+      logicalRows: rows,
+      parentByPackedId: NO_RESIDENCY,
+      rootByPackedId: NO_RESIDENCY
+    };
+  }
+  const logicalRows = rows.slice(0, firstPacked);
+  const parentByPackedId = /* @__PURE__ */ new Map();
+  const rootByPackedId = /* @__PURE__ */ new Map();
+  for (let index = firstPacked; index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === void 0) continue;
+    const decoded = decodePackedValueRow(row);
+    logicalRows.push(decoded.row, ...decoded.children);
+    for (const [parentId, childIds] of decoded.packedChildIdsByParentId) {
+      for (const childId of childIds) {
+        parentByPackedId.set(childId, parentId);
+        rootByPackedId.set(childId, row.id);
+      }
+    }
+  }
+  return { logicalRows, parentByPackedId, rootByPackedId };
+}
+function foldPackedValueWriteChanges(args) {
+  const valueChangesById = collectValueChanges(args.changes);
+  if (valueChangesById.size === 0) return args.changes;
+  const base = expandWithResidency(args.document.values);
+  if (base.rootByPackedId.size === 0 && !schemaPacksAnyMember(args.document.members)) {
+    return args.changes;
+  }
+  const basePhysicalById = /* @__PURE__ */ new Map();
+  for (const row of args.document.values) basePhysicalById.set(row.id, row);
+  const postLogicalById = /* @__PURE__ */ new Map();
+  for (const row of base.logicalRows) postLogicalById.set(row.id, row);
+  applyValueChanges(postLogicalById, valueChangesById);
+  const parentByPackedId = new Map(base.parentByPackedId);
+  const rootByPackedId = new Map(base.rootByPackedId);
+  decodePhysicalPostRows({
+    post: postLogicalById,
+    valueChangesById,
+    parentByPackedId,
+    rootByPackedId
+  });
+  releaseRedistributedResidency({
+    valueChangesById,
+    parentByPackedId,
+    rootByPackedId
+  });
+  const baseRootOf = (id2) => base.rootByPackedId.get(id2);
+  const fold = foldPackedValueRows({
+    rows: [...postLogicalById.values()],
+    document: args.document,
+    residency: { parentByPackedId, rootByPackedId },
+    encodeOnlyRootIds: touchedRootIds(valueChangesById, baseRootOf)
+  });
+  return emitFoldedValueChanges({
+    changes: args.changes,
+    valueChangesById,
+    fold,
+    basePhysicalOf: (id2) => basePhysicalById.get(id2),
+    baseRootOf
+  });
+}
+function namedIds(container) {
+  if (typeof container !== "object" || container === null) return [];
+  const entries = Array.isArray(container) ? container : Object.values(container);
+  const ids = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") ids.push(entry);
+  }
+  return ids;
+}
+function collectValueChanges(changes) {
+  const valueChangesById = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    if (change.recordKind !== ProjectRecordKind.Value) continue;
+    valueChangesById.set(change.recordId, change);
+  }
+  return valueChangesById;
+}
+function applyValueChanges(rowsById, valueChangesById) {
+  for (const change of valueChangesById.values()) {
+    if (change.deleted === true) {
+      rowsById.delete(change.recordId);
+      continue;
+    }
+    if (!isMemberValue(change.nextData)) {
+      throw new Error(
+        `Value "${change.recordId}" cannot be prepared for packed storage because its change carries no value row.`
+      );
+    }
+    rowsById.set(change.recordId, change.nextData);
+  }
+}
+function decodePhysicalPostRows(args) {
+  for (const change of args.valueChangesById.values()) {
+    if (change.deleted === true) continue;
+    const row = args.post.get(change.recordId);
+    if (row === void 0 || !rowCarriesPackedValueContent(row)) continue;
+    const decoded = decodePackedValueRow(row);
+    args.post.set(decoded.row.id, decoded.row);
+    for (const child of decoded.children) {
+      if (args.valueChangesById.has(child.id)) continue;
+      args.post.set(child.id, child);
+    }
+    for (const [parentId, childIds] of decoded.packedChildIdsByParentId) {
+      for (const childId of childIds) {
+        args.parentByPackedId.set(childId, parentId);
+        args.rootByPackedId.set(childId, row.id);
+      }
+    }
+  }
+}
+function releaseRedistributedResidency(args) {
+  for (const change of args.valueChangesById.values()) {
+    if (change.intent.type !== ProjectVersionIntentType.ValueRedistribute) {
+      continue;
+    }
+    args.parentByPackedId.delete(change.recordId);
+    args.rootByPackedId.delete(change.recordId);
+  }
+}
+function rowNamesChild(parent, childId) {
+  if (namedIds(parent.value).includes(childId)) return true;
+  if (!isLiteralValueContent(parent)) return false;
+  return namedIds(parent.constructorArgs).includes(childId);
+}
+function touchedRootIds(valueChangesById, baseRootOf) {
+  return (rootByFoldedId) => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const valueId of valueChangesById.keys()) {
+      ids.add(valueId);
+      const foldedRoot = rootByFoldedId.get(valueId);
+      if (foldedRoot !== void 0) ids.add(foldedRoot);
+      const baseRoot = baseRootOf(valueId);
+      if (baseRoot !== void 0) ids.add(baseRoot);
+    }
+    return ids;
+  };
+}
+function emitFoldedValueChanges(args) {
+  const { valueChangesById, fold } = args;
+  const postPhysicalById = /* @__PURE__ */ new Map();
+  for (const row of fold.rows) postPhysicalById.set(row.id, row);
+  const originByPhysicalId = /* @__PURE__ */ new Map();
+  const remember = (physicalId, origin) => {
+    if (physicalId === void 0) return;
+    if (originByPhysicalId.has(physicalId)) return;
+    originByPhysicalId.set(physicalId, origin);
+  };
+  for (const [valueId, change] of valueChangesById) remember(valueId, change);
+  for (const [valueId, change] of valueChangesById) {
+    remember(fold.rootByFoldedId.get(valueId), change);
+    remember(args.baseRootOf(valueId), change);
+  }
+  const folded = [];
+  const emittedIds = /* @__PURE__ */ new Set();
+  const emit = (change) => {
+    if (emittedIds.has(change.recordId)) return;
+    emittedIds.add(change.recordId);
+    folded.push(change);
+  };
+  const removeRecord = (recordId, origin) => {
+    emit({
+      ...carriedChangeFields(origin, recordId),
+      recordKind: ProjectRecordKind.Value,
+      recordId,
+      operation: ProjectVersionRecordOperation.Delete,
+      deleted: true
+    });
+  };
+  const emitPhysical = (physicalId, origin, requested) => {
+    const next = postPhysicalById.get(physicalId);
+    const storedBase = args.basePhysicalOf(physicalId);
+    if (next === void 0) {
+      if (storedBase === void 0) return;
+      removeRecord(physicalId, origin);
+      return;
+    }
+    if (!requested && storedBase !== void 0 && rowsAreIdentical(storedBase, next)) {
+      return;
+    }
+    emit({
+      ...carriedChangeFields(origin, physicalId),
+      recordKind: ProjectRecordKind.Value,
+      recordId: physicalId,
+      operation: storedBase === void 0 ? ProjectVersionRecordOperation.Create : ProjectVersionRecordOperation.Update,
+      deleted: false,
+      nextData: next
+    });
+  };
+  for (const change of args.changes) {
+    if (change.recordKind !== ProjectRecordKind.Value) {
+      folded.push(change);
+      continue;
+    }
+    const physicalId = postPhysicalById.has(change.recordId) || args.basePhysicalOf(change.recordId) !== void 0 ? change.recordId : fold.rootByFoldedId.get(change.recordId);
+    if (physicalId === void 0) continue;
+    const origin = originByPhysicalId.get(physicalId) ?? change;
+    emitPhysical(physicalId, origin, origin.recordId === physicalId);
+  }
+  for (const [physicalId, origin] of originByPhysicalId) {
+    if (emittedIds.has(physicalId)) continue;
+    emitPhysical(physicalId, origin, false);
+  }
+  for (const [foldedId, rootId] of fold.rootByFoldedId) {
+    if (args.basePhysicalOf(foldedId) === void 0) continue;
+    const origin = originByPhysicalId.get(rootId);
+    if (origin === void 0) continue;
+    removeRecord(foldedId, origin);
+  }
+  return folded;
+}
+function carriedChangeFields(origin, physicalId) {
+  if (origin.recordId === physicalId) {
+    const {
+      nextData: _nextData,
+      recordKind: _recordKind,
+      recordId: _recordId,
+      operation: _operation,
+      deleted: _deleted,
+      ...carried
+    } = origin;
+    return carried;
+  }
+  return { intent: origin.intent };
+}
+function rowsAreIdentical(left, right) {
+  if (left === right) return true;
   return canonicalJsonStringify(left) === canonicalJsonStringify(right);
 }
-function toCanonicalJsonValue(value) {
-  if (value === null) return null;
-  if (value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") return value;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error("Cannot canonicalize a non-finite number.");
+function expandPackedValueWriteChanges(args) {
+  const decodedByValueId = /* @__PURE__ */ new Map();
+  const directValueIds = /* @__PURE__ */ new Set();
+  for (const change of args.changes) {
+    if (change.recordKind !== ProjectRecordKind.Value) continue;
+    if (isDeleteChange(change)) continue;
+    directValueIds.add(change.recordId);
+    if (!isMemberValue(change.nextData)) continue;
+    if (!rowCarriesPackedValueContent(change.nextData)) continue;
+    decodedByValueId.set(
+      change.recordId,
+      decodePackedValueRow(change.nextData)
+    );
+  }
+  if (decodedByValueId.size === 0) return args.changes;
+  const packedChildIds = /* @__PURE__ */ new Set();
+  for (const decoded of decodedByValueId.values()) {
+    for (const child of decoded.children) packedChildIds.add(child.id);
+  }
+  const baseValueIds = /* @__PURE__ */ new Set();
+  for (const row of args.baseValues) baseValueIds.add(row.id);
+  const expanded = [];
+  for (const change of args.changes) {
+    if (change.recordKind !== ProjectRecordKind.Value) {
+      expanded.push(change);
+      continue;
+    }
+    if (isDeleteChange(change) && packedChildIds.has(change.recordId)) continue;
+    const decoded = decodedByValueId.get(change.recordId);
+    if (decoded === void 0) {
+      expanded.push(change);
+      continue;
+    }
+    expanded.push({ ...change, nextData: decoded.row });
+    for (const child of decoded.children) {
+      if (directValueIds.has(child.id)) continue;
+      expanded.push({
+        intent: change.intent,
+        recordKind: ProjectRecordKind.Value,
+        recordId: child.id,
+        operation: baseValueIds.has(child.id) ? ProjectVersionRecordOperation.Update : ProjectVersionRecordOperation.Create,
+        deleted: false,
+        nextData: child
+      });
     }
-    return value;
   }
-  if (typeof value === "bigint") {
-    throw new Error("Cannot canonicalize bigint values.");
+  return expanded;
+}
+function isDeleteChange(change) {
+  if (change.operation === ProjectVersionRecordOperation.Delete) return true;
+  return change.deleted === true;
+}
+var NO_FOLDED_IDS, PACKED_ANCESTOR_LIMIT, packedSchemaCache, NO_RESIDENCY;
+var init_packed_value_write_fold = __esm({
+  "../src/database/packed-value-write-fold.ts"() {
+    "use strict";
+    init_project2();
+    init_member_kinds();
+    init_effective_distribution();
+    init_member_subtree_distribution();
+    init_packed_value_encoding();
+    init_canonical_json();
+    init_constructor_argument_ownership();
+    init_variant_value_graph();
+    init_project_version_intents();
+    NO_FOLDED_IDS = /* @__PURE__ */ new Map();
+    PACKED_ANCESTOR_LIMIT = 512;
+    packedSchemaCache = /* @__PURE__ */ new WeakMap();
+    NO_RESIDENCY = /* @__PURE__ */ new Map();
   }
-  if (typeof value === "symbol") {
-    throw new Error("Cannot canonicalize symbol values.");
+});
+
+// src/project-source/packed-value-parity.ts
+function logicalValueBaseRecordsV4(records2) {
+  let expanded = null;
+  for (const [key, record3] of Object.entries(records2)) {
+    if (record3.recordKind !== "value") continue;
+    if (!isObjectRecord2(record3.data)) continue;
+    if (!rowCarriesPackedValueContent(record3.data)) continue;
+    if (!isMemberValue(record3.data)) {
+      throw new PackedValueEncodingError(
+        `Workspace base row "${key}" packs a child but is not a well-formed value row, so its packed payload cannot be expanded.`
+      );
+    }
+    const decoded = decodePackedValueRow(record3.data);
+    expanded ??= { ...records2 };
+    expanded[key] = { ...record3, data: decoded.row };
+    for (const child of decoded.children) {
+      expanded[`value:${child.id}`] = {
+        recordKind: "value",
+        recordId: child.id,
+        contentHash: record3.contentHash,
+        ...record3.file === void 0 ? {} : { file: record3.file },
+        data: child
+      };
+    }
   }
-  if (typeof value === "function") {
-    throw new Error("Cannot canonicalize function values.");
+  return expanded ?? records2;
+}
+function foldCandidateValueRowsV4(args) {
+  if (args.candidates.size === 0) return EMPTY_FOLD;
+  const rows = [];
+  const inputById = /* @__PURE__ */ new Map();
+  for (const [valueId, body] of args.candidates) {
+    const row = completeCandidateRow(valueId, body, args.base, args.projectId);
+    if (row === null) return EMPTY_FOLD;
+    rows.push(row);
+    inputById.set(valueId, row);
+  }
+  const fold = foldPackedValueRows({ rows, document: args.schema });
+  if (fold.rootByFoldedId.size === 0) return EMPTY_FOLD;
+  const adoptedRootIds = /* @__PURE__ */ new Set();
+  for (const [childId, rootId] of fold.rootByFoldedId) {
+    if (adoptedRootIds.has(rootId)) continue;
+    if (!args.touchedValueIds.has(childId) && !args.touchedValueIds.has(rootId))
+      continue;
+    adoptedRootIds.add(rootId);
   }
-  if (Array.isArray(value)) {
-    return value.map((item) => {
-      const canonicalItem = toCanonicalJsonValue(item);
-      if (canonicalItem === void 0) return null;
-      return canonicalItem;
+  if (adoptedRootIds.size === 0) return EMPTY_FOLD;
+  const foldedValueIds = /* @__PURE__ */ new Set();
+  for (const [childId, rootId] of fold.rootByFoldedId) {
+    if (adoptedRootIds.has(rootId)) foldedValueIds.add(childId);
+  }
+  const bodyByValueId = /* @__PURE__ */ new Map();
+  for (const row of fold.rows) {
+    if (!adoptedRootIds.has(row.id)) continue;
+    if (row === inputById.get(row.id)) continue;
+    const candidate = args.candidates.get(row.id);
+    if (candidate === void 0) {
+      throw new PackedValueEncodingError(
+        `Packed fold produced a physical row for "${row.id}", which is not a candidate value row of this push.`
+      );
+    }
+    bodyByValueId.set(row.id, storedContentApplied(candidate, row));
+  }
+  return { bodyByValueId, foldedValueIds };
+}
+function completeCandidateRow(valueId, body, base, projectId) {
+  if (isMemberValue(body)) return body;
+  const stored = base[`value:${valueId}`]?.data;
+  const envelope = isObjectRecord2(stored) ? stored : void 0;
+  const completed = { ...body, id: valueId };
+  if (typeof completed.projectId !== "string") {
+    completed.projectId = projectId;
+  }
+  if (!isEpochMillis(completed.createdAt)) {
+    completed.createdAt = isEpochMillis(envelope?.createdAt) ? envelope.createdAt : 0;
+  }
+  if (!isEpochMillis(completed.updatedAt)) {
+    completed.updatedAt = isEpochMillis(envelope?.updatedAt) ? envelope.updatedAt : 0;
+  }
+  return isMemberValue(completed) ? completed : null;
+}
+function storedContentApplied(candidate, row) {
+  if (!isLiteralValueContent(row)) {
+    throw new PackedValueEncodingError(
+      `Packed fold rewrote value "${row.id}", which stores an initializer rather than a literal body.`
+    );
+  }
+  const applied = { ...candidate, value: row.value };
+  if (Object.hasOwn(row, "constructorArgs")) {
+    applied.constructorArgs = row.constructorArgs;
+  } else {
+    delete applied.constructorArgs;
+  }
+  return applied;
+}
+var EMPTY_FOLD;
+var init_packed_value_parity = __esm({
+  "src/project-source/packed-value-parity.ts"() {
+    "use strict";
+    init_core();
+    init_members();
+    init_packed_value_write_fold();
+    init_projection();
+    EMPTY_FOLD = {
+      bodyByValueId: /* @__PURE__ */ new Map(),
+      foldedValueIds: /* @__PURE__ */ new Set()
+    };
+  }
+});
+
+// ../src/database/headless-virtual-instance-lookups.ts
+function headlessVirtualInstanceLookups(document, options = {}) {
+  const members = document.members;
+  const expandedDocument = expandPackedDocumentValues(document);
+  const values = expandedDocument.values;
+  const indexed = makeEvaluatorLookups(
+    members,
+    values,
+    options.includeValueGraphIndexes === true ? {
+      includeValueGraphIndexes: true,
+      constructorInitializerDocument: {
+        classes: document.classes,
+        members,
+        values
+      }
+    } : {}
+  );
+  const virtual = createHeadlessVirtualInstanceResolver({
+    document: {
+      ...expandedDocument,
+      ...options.initializerCompiler === void 0 ? {} : { initializerCompiler: options.initializerCompiler }
+    },
+    // A thunk: the resolver resolves nested reads through the lookups being
+    // built around it.
+    resolverLookups: () => lookups
+  });
+  const lookups = {
+    ...indexed,
+    // Raw first, then virtual: a materialized row always wins over the
+    // expansion that would otherwise answer for it.
+    valueById: (id2) => indexed.valueById(id2) ?? virtual.valueById(id2),
+    rowForValueReference: (value) => indexed.rowForValueReference(value) ?? virtual.rowForValueReference(value),
+    virtualInstanceRowsForValue: (receiverValueId) => virtual.virtualInstanceRowsForValue(receiverValueId),
+    // Stored-construction replay evaluates `ToVariant`, and production's
+    // variant-constructed placements collapse through exactly this path.
+    resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
+      document,
+      resolverLookups: lookups,
+      ...args
+    }),
+    // A write to a virtual key must MATERIALIZE it (a pin row at the
+    // deterministic virtual id plus the sparse spine); the planner needs the
+    // owning graph, not just its rows.
+    virtualInstanceGraphForValue: (valueId) => virtual.virtualInstanceGraphForValue(valueId)
+  };
+  return lookups;
+}
+var init_headless_virtual_instance_lookups = __esm({
+  "../src/database/headless-virtual-instance-lookups.ts"() {
+    "use strict";
+    init_virtual_instance_values();
+    init_packed_value_encoding();
+    init_neoscript_evaluator();
+  }
+});
+
+// src/evaluator-lookups.ts
+function cliEvaluatorLookups(document, options = {}) {
+  return cliEvaluatorRuntime(document, options).databaseVM;
+}
+function cliEvaluatorRuntime(document, options = {}) {
+  const initializerCompiler = isPulledInitializerCompilationDocumentV4(document) ? pulledInitializerCompilerV4(document) : void 0;
+  const databaseVM = headlessVirtualInstanceLookups(document, {
+    ...options,
+    ...initializerCompiler === void 0 ? {} : { initializerCompiler }
+  });
+  return {
+    databaseVM,
+    ...initializerCompiler === void 0 ? {} : { initializerCompiler }
+  };
+}
+function cliEvaluatorReceiverValue(lookups, valueId) {
+  if (typeof valueId !== "string") return null;
+  return lookups.valueById(valueId)?.value ?? null;
+}
+var init_evaluator_lookups = __esm({
+  "src/evaluator-lookups.ts"() {
+    "use strict";
+    init_headless_virtual_instance_lookups();
+    init_initializer_replay();
+  }
+});
+
+// src/project-source/materialized-construction-cache.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { dirname as dirname2, join as join3 } from "node:path";
+function createMaterializedConstructionExpressionsV1(args) {
+  const warm = args.useBuildCaches ? readMaterializedConstructionBuildCacheV2(args.root, args.state) : null;
+  const emitted = /* @__PURE__ */ new Map();
+  const overrideKeys = /* @__PURE__ */ new Map();
+  let emitters;
+  return {
+    get(valueId) {
+      const cached = warm?.expressions.get(valueId);
+      if (cached !== void 0) return cached;
+      if (emitted.has(valueId)) return emitted.get(valueId);
+      emitters ??= storedConstructionEmitters(args.state, args.manifest);
+      const expression = emitters.construction(valueId);
+      emitted.set(valueId, expression);
+      return expression;
+    },
+    overrideSchemaKeys(valueId) {
+      const cached = warm?.overrideKeys.get(valueId);
+      if (cached !== void 0) return cached;
+      if (overrideKeys.has(valueId)) return overrideKeys.get(valueId);
+      emitters ??= storedConstructionEmitters(args.state, args.manifest);
+      const keys = emitters.overrideSchemaKeys(valueId);
+      overrideKeys.set(valueId, keys);
+      return keys;
+    }
+  };
+}
+function storedConstructionEmitters(state, manifest) {
+  const records2 = /* @__PURE__ */ new Map();
+  const candidateRoots = /* @__PURE__ */ new Set();
+  for (const record3 of Object.values(state.records)) {
+    records2.set(`${record3.recordKind}:${record3.recordId}`, {
+      recordKind: record3.recordKind,
+      recordId: record3.recordId,
+      contentHash: record3.contentHash,
+      deleted: false,
+      data: record3.data
     });
+    if (record3.recordKind !== "value") continue;
+    if (!isObjectRecord2(record3.data)) continue;
+    if (!isObjectRecord2(record3.data.value)) continue;
+    const constructorArgs = record3.data.constructorArgs;
+    const hasInstanceProvenance = carriesStoredInstanceProvenance(record3.data);
+    if (constructorArgs !== void 0 && constructorArgs !== null && !hasInstanceProvenance) {
+      continue;
+    }
+    candidateRoots.add(record3.recordId);
   }
-  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
-  const canonicalObject = {};
-  for (const [key, entryValue] of entries) {
-    const canonicalValue = toCanonicalJsonValue(entryValue);
-    if (canonicalValue === void 0) continue;
-    canonicalObject[key] = canonicalValue;
+  const document = readPulledProjectDocumentV4(records2);
+  const owners = resolveOwnerMembersForValues(document, candidateRoots);
+  const storedPlacements = buildStoredValuePlacementIndexV4(records2.values());
+  const membersById2 = new Map(
+    document.members.map((member) => [member.id, member])
+  );
+  for (const valueId of candidateRoots) {
+    if (owners.has(valueId)) continue;
+    const memberId = storedPlacements.placementByChildValueId.get(valueId)?.memberId;
+    const member = memberId === null || memberId === void 0 ? void 0 : membersById2.get(memberId);
+    if (member !== void 0) owners.set(valueId, member);
   }
-  return canonicalObject;
+  const probe = createStoredConstructionProbeV4(records2, manifest);
+  let parents;
+  const parentByChildId = () => parents ??= storedValueParentIndex(records2, storedPlacements);
+  const root = (valueId) => {
+    const member = owners.get(valueId);
+    return member === void 0 ? void 0 : {
+      member,
+      valueId
+    };
+  };
+  const probedRootIds = /* @__PURE__ */ new Set();
+  const probeRootOnce = (rootValueId, ownedRoot) => {
+    if (probedRootIds.has(rootValueId)) {
+      return /* @__PURE__ */ new Set();
+    }
+    probedRootIds.add(rootValueId);
+    return probe.overrideKeys(ownedRoot);
+  };
+  return {
+    construction(valueId) {
+      const ownedRoot = root(valueId);
+      if (ownedRoot === void 0) return void 0;
+      return probe.construction(ownedRoot);
+    },
+    overrideSchemaKeys(valueId) {
+      const recorded = probe.overrideKeysOf(valueId);
+      if (recorded !== void 0) return recorded;
+      const ownedRoot = root(valueId);
+      if (ownedRoot !== void 0) return probeRootOnce(valueId, ownedRoot);
+      const ancestor = nearestOwnedAncestor(valueId, parentByChildId(), owners);
+      if (ancestor === null) return void 0;
+      const ancestorRoot = root(ancestor);
+      if (ancestorRoot === void 0) return void 0;
+      if (probedRootIds.has(ancestor)) return void 0;
+      probeRootOnce(ancestor, ancestorRoot);
+      return probe.overrideKeysOf(valueId);
+    }
+  };
 }
-var init_canonical_json = __esm({
-  "../src/database/canonical-json.ts"() {
+function storedValueParentIndex(records2, placements) {
+  const parents = /* @__PURE__ */ new Map();
+  const values = storedValueRowsByIdV4(records2.values());
+  for (const [valueId, data] of values) {
+    const containerId = data.containerId;
+    if (typeof containerId === "string" && values.has(containerId)) {
+      parents.set(valueId, containerId);
+    }
+    const body = data.value;
+    if (Array.isArray(body)) {
+      for (const entry of body) {
+        if (typeof entry === "string" && values.has(entry)) {
+          parents.set(entry, valueId);
+        }
+      }
+      continue;
+    }
+    if (!isObjectRecord2(body)) continue;
+    for (const child of Object.values(body)) {
+      if (typeof child === "string" && values.has(child)) {
+        parents.set(child, valueId);
+      }
+    }
+  }
+  for (const edge of placements.placementByChildValueId.values()) {
+    if (edge.source !== "constructor") continue;
+    if (!parents.has(edge.childValueId)) {
+      parents.set(edge.childValueId, edge.parentValueId);
+    }
+  }
+  return parents;
+}
+function nearestOwnedAncestor(valueId, parents, owners) {
+  const seen = /* @__PURE__ */ new Set([valueId]);
+  let cursor = parents.get(valueId);
+  while (cursor !== void 0 && !seen.has(cursor)) {
+    if (owners.has(cursor)) return cursor;
+    seen.add(cursor);
+    cursor = parents.get(cursor);
+  }
+  return null;
+}
+function carriesStoredInstanceProvenance(value) {
+  return isVirtualInstanceRootShape(value);
+}
+function readMaterializedConstructionBuildCacheV2(root, state) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync3(
+        join3(root, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH),
+        "utf8"
+      )
+    );
+    if (parsed === null || typeof parsed !== "object") return null;
+    const cache = parsed;
+    if (cache.revision !== MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION || cache.stateFingerprint !== materializedConstructionStateFingerprint(state) || cache.expressions === null || typeof cache.expressions !== "object" || Array.isArray(cache.expressions)) {
+      return null;
+    }
+    const expressions = /* @__PURE__ */ new Map();
+    for (const [valueId, expression] of Object.entries(cache.expressions)) {
+      if (typeof expression !== "string") return null;
+      expressions.set(valueId, expression);
+    }
+    const overrideKeys = /* @__PURE__ */ new Map();
+    if (cache.overrideKeys !== void 0) {
+      if (cache.overrideKeys === null || typeof cache.overrideKeys !== "object" || Array.isArray(cache.overrideKeys)) {
+        return null;
+      }
+      for (const [valueId, keys] of Object.entries(cache.overrideKeys)) {
+        if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) {
+          return null;
+        }
+        overrideKeys.set(valueId, new Set(keys));
+      }
+    }
+    return { expressions, overrideKeys };
+  } catch {
+    return null;
+  }
+}
+function writeMaterializedConstructionBuildCacheV2(root, state, cache) {
+  const file = join3(root, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH);
+  mkdirSync3(dirname2(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync3(
+    temporary,
+    `${JSON.stringify({
+      revision: MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION,
+      stateFingerprint: materializedConstructionStateFingerprint(state),
+      expressions: Object.fromEntries(
+        [...cache.expressions].sort(
+          ([left], [right]) => left.localeCompare(right)
+        )
+      ),
+      overrideKeys: Object.fromEntries(
+        [...cache.overrideKeys ?? /* @__PURE__ */ new Map()].sort(([left], [right]) => left.localeCompare(right)).map(([valueId, keys]) => [valueId, [...keys].sort()])
+      )
+    })}
+`,
+    "utf8"
+  );
+  renameSync(temporary, file);
+}
+function materializedConstructionStateFingerprint(state) {
+  const hash = createHash3("sha256");
+  hash.update(String(MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION));
+  for (const [key, record3] of Object.entries(state.records).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    hash.update("\0");
+    hash.update(key);
+    hash.update("\0");
+    hash.update(record3.contentHash);
+  }
+  return hash.digest("hex");
+}
+var MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH, MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION;
+var init_materialized_construction_cache = __esm({
+  "src/project-source/materialized-construction-cache.ts"() {
     "use strict";
+    init_projection();
+    init_initializer_replay();
+    init_value_row_owner_members();
+    init_instance_provenance();
+    init_value_sources();
+    init_stored_value_placements();
+    MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH = ".neo/build/materialized-constructions-v1.json";
+    MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION = 2;
   }
 });
 
@@ -87444,7 +89090,10 @@ function generatedConstructorMemberContractChanged(current, next) {
     "indexes",
     "setter",
     "setterCode",
-    "storage"
+    "storage",
+    // Where a value physically lives does not change the generated
+    // constructor's parameter contract (P76 §1).
+    "distribution"
   ]);
   const project = (value) => ({
     ...withoutFields(value, ignored),
@@ -88268,7 +89917,9 @@ function valueRowsFromWorkspace(workspace) {
         `Workspace contains invalid value row "${record3.recordId}".`
       );
     }
-    rows.set(record3.recordId, record3.data);
+    const decoded = decodePackedValueRow(record3.data);
+    rows.set(record3.recordId, decoded.row);
+    for (const child of decoded.children) rows.set(child.id, child);
   }
   return rows;
 }
@@ -88361,7 +90012,7 @@ function materializeInitializersLocallyV4(args) {
       }
       return [row];
     });
-    const sparse = sparsifyConstructedInstance({
+    const sparse2 = sparsifyConstructedInstance({
       document,
       rootMember: rootOwner,
       constructed: {
@@ -88379,12 +90030,12 @@ function materializeInitializersLocallyV4(args) {
       virtualValueIdForSource: (instanceRootId, sourceIdentity3) => isPendingId(instanceRootId) ? pendingVirtualValueId(instanceRootId, sourceIdentity3) : virtualValueId(instanceRootId, sourceIdentity3)
     });
     const evaluatedSparse = new Map(
-      [sparse.root, ...sparse.createdChildren].map((row) => [row.id, row])
+      [sparse2.root, ...sparse2.createdChildren].map((row) => [row.id, row])
     );
-    const root = sparse.root;
-    const createdIds = sparse.createdChildren.map((row) => row.id);
+    const root = sparse2.root;
+    const createdIds = sparse2.createdChildren.map((row) => row.id);
     const replacements = /* @__PURE__ */ new Map();
-    const evaluatedRows = [root, ...sparse.createdChildren];
+    const evaluatedRows = [root, ...sparse2.createdChildren];
     const valuesById = new Map(
       document.values.map((row) => [row.id, row])
     );
@@ -88590,103 +90241,6 @@ var init_local_initializer_materialization = __esm({
   }
 });
 
-// ../src/database/project-version-intents.ts
-function createProjectVersionIntent(type, details) {
-  if (details === void 0) {
-    return {
-      type,
-      schemaVersion: PROJECT_VERSION_INTENT_SCHEMA_VERSION
-    };
-  }
-  return {
-    type,
-    schemaVersion: PROJECT_VERSION_INTENT_SCHEMA_VERSION,
-    details
-  };
-}
-function isKnownProjectVersionIntentType(value) {
-  return Object.values(ProjectVersionIntentType).includes(
-    value
-  );
-}
-var ProjectVersionIntentType, PROJECT_VERSION_INTENT_SCHEMA_VERSION;
-var init_project_version_intents = __esm({
-  "../src/database/project-version-intents.ts"() {
-    "use strict";
-    ProjectVersionIntentType = {
-      ProjectCreate: "project.create",
-      ProjectUpdate: "project.update",
-      MemberCreate: "member.create",
-      MemberUpdate: "member.update",
-      MemberRename: "member.rename",
-      MemberSetValue: "member.set-value",
-      MemberClearValue: "member.clear-value",
-      MemberDelete: "member.delete",
-      ClassCreate: "class.create",
-      ClassUpdate: "class.update",
-      ClassDelete: "class.delete",
-      ClassAddSchemaEntry: "class.add-schema-entry",
-      ConstructorCreate: "constructor.create",
-      ConstructorUpdate: "constructor.update",
-      ConstructorDelete: "constructor.delete",
-      VariantCreate: "variant.create",
-      VariantUpdate: "variant.update",
-      VariantDelete: "variant.delete",
-      VariantFolderCreate: "variant-folder.create",
-      VariantFolderUpdate: "variant-folder.update",
-      VariantFolderDelete: "variant-folder.delete",
-      InternalRecordRelationCreate: "internal-record-relation.create",
-      InternalRecordRelationUpdate: "internal-record-relation.update",
-      InternalRecordRelationDelete: "internal-record-relation.delete",
-      EnumCreate: "enum.create",
-      EnumUpdate: "enum.update",
-      EnumDelete: "enum.delete",
-      InterfaceCreate: "interface.create",
-      InterfaceUpdate: "interface.update",
-      InterfaceDelete: "interface.delete",
-      EnumOptionRename: "enum-option.rename",
-      EnumOptionDelete: "enum-option.delete",
-      ValueCreate: "value.create",
-      ValueUpdate: "value.update",
-      ValueDelete: "value.delete",
-      ValueEntryRenameKey: "value-entry.rename-key",
-      DialogueCreate: "dialogue.create",
-      DialogueUpdate: "dialogue.update",
-      DialogueDelete: "dialogue.delete",
-      DialogueNodeCreate: "dialogue-node.create",
-      DialogueNodeUpdate: "dialogue-node.update",
-      DialogueNodeDelete: "dialogue-node.delete",
-      DialogueGroupCreate: "dialogue-group.create",
-      DialogueGroupUpdate: "dialogue-group.update",
-      DialogueGroupDelete: "dialogue-group.delete",
-      PriorityGroupCreate: "priority-group.create",
-      PriorityGroupUpdate: "priority-group.update",
-      PriorityGroupDelete: "priority-group.delete",
-      ProjectFileCreate: "project-file.create",
-      ProjectFileUpdate: "project-file.update",
-      ProjectFileDelete: "project-file.delete",
-      UnityTextureTemplateCreate: "unity-texture-template.create",
-      UnityTextureTemplateUpdate: "unity-texture-template.update",
-      UnityTextureTemplateDelete: "unity-texture-template.delete",
-      UnityAudioClipTemplateCreate: "unity-audio-clip-template.create",
-      UnityAudioClipTemplateUpdate: "unity-audio-clip-template.update",
-      UnityAudioClipTemplateDelete: "unity-audio-clip-template.delete",
-      LocalizationConfigCreate: "localization-config.create",
-      LocalizationConfigUpdate: "localization-config.update",
-      LocalizationStatusCreate: "localization-status.create",
-      LocalizationStatusUpdate: "localization-status.update",
-      LocalizationStatusDelete: "localization-status.delete",
-      LocalizedTextCreate: "localized-text.create",
-      LocalizedTextUpdate: "localized-text.update",
-      LocalizedTextDelete: "localized-text.delete",
-      MigrationCreate: "migration.create",
-      MigrationUpdate: "migration.update",
-      MigrationDelete: "migration.delete"
-    };
-    PROJECT_VERSION_INTENT_SCHEMA_VERSION = 1;
-  }
-});
-
 // src/commands/push-change-intent.ts
 function createNeoCliPushIntent(change) {
   const intentType = `${change.recordKind}.${change.kind}`;
@@ -93514,6 +95068,7 @@ var init_project_migration_runner = __esm({
     init_compiler_adapter();
     init_neoscript_evaluator();
     init_members();
+    init_packed_value_encoding();
     init_project_root_members();
     init_virtual_instance_values();
     init_project_version_intents();
@@ -95691,7 +97246,9 @@ function materializeLocalizableStringWriteChanges(args) {
       ...change,
       nextData: { ...change.nextData, value: textId }
     };
-    changes.push(
+    changes.splice(
+      index + 1,
+      0,
       localizedTextCreateChange({
         textId,
         literal: literal2,
@@ -96233,12 +97790,87 @@ function prepareServerOwnedSchemaCommit(args) {
     document: committedDocument,
     prepared
   });
-  attachPreparedValuePlacements(prepared, committedDocument);
-  attachPreparedConstructorAggregateEdges(prepared, committedDocument);
-  return orderVariantRootValuesWithVariants(
-    orderDeclaredMemberCreatesFirst(prepared, postDocument)
+  const physical = foldPreparedPackedValueWrites({
+    prepared,
+    document: args.document,
+    committedDocument
+  });
+  attachPreparedValuePlacements(physical, committedDocument);
+  attachPreparedConstructorAggregateEdges(physical, committedDocument);
+  return orderLocalizedTextWritesBesideLinks(
+    orderVariantRootValuesWithVariants(
+      orderDeclaredMemberCreatesFirst(physical, postDocument)
+    )
   );
 }
+function orderLocalizedTextWritesBesideLinks(prepared) {
+  const indexByLinkKey = /* @__PURE__ */ new Map();
+  prepared.forEach((change, index) => {
+    if (change.operation === "delete") return;
+    if (change.recordKind !== "value" && change.recordKind !== "dialogue" && change.recordKind !== "dialogue-node") {
+      return;
+    }
+    indexByLinkKey.set(`${change.recordKind}:${change.recordId}`, index);
+  });
+  if (indexByLinkKey.size === 0) return [...prepared];
+  const followersByIndex = /* @__PURE__ */ new Map();
+  const moved = /* @__PURE__ */ new Set();
+  prepared.forEach((change, index) => {
+    if (change.recordKind !== "localized-text") return;
+    if (change.operation === "delete") return;
+    let anchor = -1;
+    for (const link of localizedTextLinkKeys(change.nextData)) {
+      const linked = indexByLinkKey.get(link);
+      if (linked !== void 0 && linked > anchor) anchor = linked;
+    }
+    if (anchor < 0) return;
+    const followers = followersByIndex.get(anchor) ?? [];
+    followers.push(change);
+    followersByIndex.set(anchor, followers);
+    moved.add(index);
+  });
+  if (moved.size === 0) return [...prepared];
+  const ordered = [];
+  prepared.forEach((change, index) => {
+    if (moved.has(index)) return;
+    ordered.push(change);
+    const followers = followersByIndex.get(index);
+    if (followers !== void 0) ordered.push(...followers);
+  });
+  return ordered;
+}
+function localizedTextLinkKeys(nextData) {
+  const links = nextData?.links;
+  if (!Array.isArray(links)) return [];
+  const keys = [];
+  for (const link of links) {
+    if (typeof link !== "object" || link === null) continue;
+    const { recordKind, recordId } = link;
+    if (typeof recordKind !== "string" || typeof recordId !== "string") {
+      continue;
+    }
+    keys.push(`${recordKind}:${recordId}`);
+  }
+  return keys;
+}
+function foldPreparedPackedValueWrites(args) {
+  if (args.document.physicalValues === void 0) return args.prepared;
+  const folded = foldPackedValueWriteChanges({
+    changes: args.prepared,
+    document: {
+      classes: args.committedDocument.classes,
+      members: args.committedDocument.members,
+      constructors: args.committedDocument.constructors,
+      // P67 §2.2. Post-transaction variants, so a variant this transaction
+      // creates places the graph it creates with it.
+      variants: args.committedDocument.variants,
+      variantFolders: args.committedDocument.variantFolders,
+      values: args.document.physicalValues
+    }
+  });
+  if (folded === args.prepared) return args.prepared;
+  return [...folded];
+}
 function attachPreparedValuePlacements(prepared, document) {
   const creates = prepared.filter(
     (change) => change.recordKind === "value" && change.operation === "create"
@@ -96449,7 +98081,7 @@ function materializePreparedInstanceInitializers(args) {
       constructionBaselineReplay: true,
       storedConstructionReplay: true
     });
-    const sparse = sparsifyConstructedInstance({
+    const sparse2 = sparsifyConstructedInstance({
       document: materializationScope.document,
       rootMember: member,
       constructed: {
@@ -96469,9 +98101,9 @@ function materializePreparedInstanceInitializers(args) {
     if (original === void 0) continue;
     args.prepared[site.index] = {
       ...original,
-      nextData: sparse.root
+      nextData: sparse2.root
     };
-    for (const created of sparse.createdChildren) {
+    for (const created of sparse2.createdChildren) {
       const existing = existingValueById.get(created.id);
       if (existing !== void 0) {
         if (materializedValueRowsEqual(existing, created)) continue;
@@ -99848,6 +101480,7 @@ var init_project_version_schema_commit = __esm({
     init_localizable_member_value_writes();
     init_value_row_owner_members();
     init_init_backed_value_materialization();
+    init_packed_value_write_fold();
     init_constructor_argument_ownership();
     init_constructors2();
     init_dialogue_node_index();
@@ -100514,38 +102147,28 @@ function assertProjectVersionWholeGraphWritesValid(args) {
       `Project version transaction operation "${args.operation}" is not a known operation.`
     );
   }
-  const projected = applyProjectVersionWriteChanges(
-    args.document,
-    args.changes
-  );
-  assertNoValueDematerialization({
-    document: args.document,
-    changes: args.changes
+  const changes = expandPackedValueWriteChanges({
+    changes: args.changes,
+    baseValues: args.document.values
   });
-  assertStagedUnorderedContainmentValid(args.document, projected, args.changes);
-  assertStagedSchemaIdentifiersValid(projected, args.changes);
-  assertStagedActionListenersValid(projected, args.changes);
-  assertStagedVariantMemberValuesValid(projected, args.changes);
-  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
-  );
+  const projected = applyProjectVersionWriteChanges(args.document, changes);
+  assertNoValueDematerialization({ document: args.document, changes });
+  assertStagedUnorderedContainmentValid(args.document, projected, changes);
+  assertStagedSchemaIdentifiersValid(projected, changes);
+  assertStagedActionListenersValid(projected, changes);
+  assertStagedVariantMemberValuesValid(projected, changes);
+  assertStagedUnitySingletonValid(projected, changes);
+  assertStagedProjectInterfaceValid(projected, changes);
+  assertStagedTileGridReferencesValid(args.document, projected, changes);
+  assertStagedInternalRecordRelationsValid(args.document, projected, changes);
+  assertStagedWorldContentLayerBindingsValid(args.document, projected, changes);
   assertAnimationClipDocumentValid(
     materializeDeclarationInitializersForAnimationValidation(projected)
   );
   if (args.operation === void 0 || !isSystemOwnedProjectVersionOperation(args.operation)) {
     assertProjectVersionSystemProtectedWritesValid({
       document: args.document,
-      changes: args.changes
+      changes
     });
   }
 }
@@ -100569,12 +102192,17 @@ function assertStagedUnorderedContainmentValid(current, projected, changes) {
     const after = projectedValues.get(change.recordId);
     const beforeContainerId = typeof before?.containerId === "string" ? before.containerId : null;
     const afterContainerId = typeof after?.containerId === "string" ? after.containerId : null;
-    if (before !== void 0 && after !== void 0 && beforeContainerId !== afterContainerId) {
+    if (before !== void 0 && after !== void 0 && beforeContainerId !== afterContainerId && !isStagedContainerRename(
+      currentValues,
+      projectedValues,
+      beforeContainerId,
+      afterContainerId
+    )) {
       throw new Error(
-        `Value "${change.recordId}" cannot change containerId from ${beforeContainerId === null ? "unset" : `"${beforeContainerId}"`} to ${afterContainerId === null ? "unset" : `"${afterContainerId}"`}: unordered-list membership is stamped at creation and immutable (move = delete + recreate).`
+        `Value "${change.recordId}" cannot change containerId from ${beforeContainerId === null ? "unset" : `"${beforeContainerId}"`} to ${afterContainerId === null ? "unset" : `"${afterContainerId}"`}: unordered-list membership is stamped at creation and immutable (a move is refused; a rename must delete the old container and create the new one in the same transaction).`
       );
     }
-    if (before === void 0 && afterContainerId !== null) {
+    if (afterContainerId !== null && afterContainerId !== beforeContainerId) {
       if (afterContainerId === change.recordId) {
         throw new Error(
           `Value "${change.recordId}" cannot declare itself as its own containerId.`
@@ -100608,6 +102236,14 @@ function assertStagedUnorderedContainmentValid(current, projected, changes) {
     }
   }
 }
+function isStagedContainerRename(currentValues, projectedValues, fromContainerId, toContainerId) {
+  if (fromContainerId === null) return false;
+  if (toContainerId === null) return false;
+  if (!currentValues.has(fromContainerId)) return false;
+  if (projectedValues.has(fromContainerId)) return false;
+  if (currentValues.has(toContainerId)) return false;
+  return projectedValues.has(toContainerId);
+}
 function assertNoValueDematerialization(args) {
   const updates = args.changes.filter(
     (change) => change.recordKind === "value" && change.operation === "update" && change.deleted !== true
@@ -101609,6 +103245,7 @@ var init_project_version_whole_graph_validation = __esm({
     init_animation_clips();
     init_projectInterfaceValidation();
     init_project_schema_identifier_validation();
+    init_packed_value_write_fold();
     init_project_version_schema_commit();
     init_project_version_system_protection_writes();
     init_reserved_record_id_validation();
@@ -101783,7 +103420,9 @@ function computeWorkspaceStatus(workspace, options) {
       binaryFiles: []
     };
   }
-  const loweringRecords = loweringBaseRecords(workspace.state.records);
+  const loweringRecords = logicalValueBaseRecordsV4(
+    loweringBaseRecords(workspace.state.records)
+  );
   const baseDocuments = schemaBaseDocuments(workspace);
   const staticMemberOwnershipRecoveries = [];
   const baseManifest = baseDocuments.length === 0 ? void 0 : documentsToProjectSchemaManifest(baseDocuments, {
@@ -102180,12 +103819,15 @@ function computeWorkspaceStatus(workspace, options) {
       }
       continue;
     }
-    const baseState = workspace.state.records[key];
     const schemaDocument = documentsByKey.get(key);
-    const reconstructedData = schemaDocument === void 0 ? mergeMigrationServerFields(record3.fileFields, baseState?.data) : schemaDocument.data;
+    const reconstructedData = schemaDocument === void 0 ? mergeMigrationServerFields(
+      record3.fileFields,
+      loweringRecords[key]?.data
+    ) : schemaDocument.data;
     const staticValueId = record3.recordKind === "member" ? staticMemberValueIds.get(record3.recordId) : void 0;
     const fullData = staticValueId === void 0 ? reconstructedData : { ...reconstructedData, valueId: staticValueId };
     reconstructed3.set(key, { ...record3, fullData });
+    const baseState = workspace.state.records[key];
     if (baseState === void 0 || isPendingId(record3.recordId)) {
       changes.push({
         kind: "create",
@@ -102326,6 +103968,18 @@ function computeWorkspaceStatus(workspace, options) {
       changes.splice(index, 1);
     }
   }
+  applyPackedValueFoldV4({
+    workspace,
+    loweringRecords,
+    schema: packedFoldSchemaV4(
+      documents,
+      loweringRecords,
+      workspace.config.projectId
+    ),
+    reconstructed: reconstructed3,
+    changes
+  });
+  reportPhase("packed-value-fold");
   for (const change of changes) {
     if (change.recordKind !== "value" || change.kind !== "update") continue;
     const refusal = valueDematerializationRefusal({
@@ -102741,7 +104395,7 @@ function prospectiveAnimationDocumentV4(records2) {
   }
   if (project === void 0) return null;
   const classIdByName = new Map(classes.map((value) => [value.name, value.id]));
-  const validationValues = values.map((value) => {
+  const validationValues = expandPackedValueRows(values).map((value) => {
     if (typeof value.classId === "string") return value;
     const authoredInit = Reflect.get(value, "init");
     const init = isObjectRecord2(authoredInit) ? authoredInit : null;
@@ -102795,6 +104449,154 @@ function expandProspectiveAnimationInstances(document) {
   }
   return [...byId.values()];
 }
+function applyPackedValueFoldV4(args) {
+  const candidates = /* @__PURE__ */ new Map();
+  const touchedValueIds = /* @__PURE__ */ new Set();
+  for (const [key, record3] of args.reconstructed) {
+    if (record3.recordKind !== "value") continue;
+    candidates.set(record3.recordId, record3.fullData);
+    const logicalBase = args.loweringRecords[key];
+    const physicalBase = args.workspace.state.records[key];
+    if (logicalBase === void 0 || physicalBase === void 0 || physicalBase.conflictServerHash !== void 0 || isPendingId(record3.recordId) || !recordsSemanticallyEqual("value", record3.fullData, logicalBase.data)) {
+      touchedValueIds.add(record3.recordId);
+    }
+  }
+  const fold = foldCandidateValueRowsV4({
+    candidates,
+    base: args.loweringRecords,
+    touchedValueIds,
+    projectId: args.workspace.config.projectId,
+    schema: args.schema
+  });
+  if (fold.foldedValueIds.size === 0) return;
+  const changeForValue = (valueId, nextData) => {
+    const key = recordStateKey("value", valueId);
+    const file = args.reconstructed.get(key)?.file ?? null;
+    const base = args.workspace.state.records[key];
+    if (base === void 0 || isPendingId(valueId)) {
+      return {
+        kind: "create",
+        recordKind: "value",
+        recordId: valueId,
+        file,
+        nextData
+      };
+    }
+    if (base.conflictServerHash === void 0 && recordsSemanticallyEqual("value", nextData, base.data)) {
+      return null;
+    }
+    return recordUpsertChange({
+      base,
+      recordKind: "value",
+      recordId: valueId,
+      file,
+      nextData
+    });
+  };
+  const rewritten = [];
+  const rebuiltRootIds = /* @__PURE__ */ new Set();
+  const deletedValueIds = /* @__PURE__ */ new Set();
+  for (const change of args.changes) {
+    if (change.recordKind !== "value") {
+      rewritten.push(change);
+      continue;
+    }
+    if (change.kind === "delete") {
+      deletedValueIds.add(change.recordId);
+      rewritten.push(change);
+      continue;
+    }
+    if (fold.foldedValueIds.has(change.recordId)) continue;
+    const packedBody = fold.bodyByValueId.get(change.recordId);
+    if (packedBody === void 0) {
+      rewritten.push(change);
+      continue;
+    }
+    rebuiltRootIds.add(change.recordId);
+    const rebuilt = changeForValue(change.recordId, packedBody);
+    if (rebuilt !== null) rewritten.push(rebuilt);
+  }
+  for (const [rootId, packedBody] of fold.bodyByValueId) {
+    if (rebuiltRootIds.has(rootId)) continue;
+    const rebuilt = changeForValue(rootId, packedBody);
+    if (rebuilt !== null) rewritten.push(rebuilt);
+  }
+  for (const valueId of fold.foldedValueIds) {
+    if (deletedValueIds.has(valueId)) continue;
+    const key = recordStateKey("value", valueId);
+    const base = args.workspace.state.records[key];
+    if (base === void 0) continue;
+    rewritten.push({
+      kind: "delete",
+      recordKind: "value",
+      recordId: valueId,
+      file: base.file ?? args.reconstructed.get(key)?.file ?? null,
+      baseData: base.data,
+      baseContentHash: base.contentHash,
+      casBaseHash: base.conflictServerHash ?? base.contentHash
+    });
+  }
+  args.changes.length = 0;
+  args.changes.push(...rewritten);
+  for (const valueId of fold.foldedValueIds) {
+    args.reconstructed.delete(recordStateKey("value", valueId));
+  }
+  for (const [rootId, packedBody] of fold.bodyByValueId) {
+    const key = recordStateKey("value", rootId);
+    const record3 = args.reconstructed.get(key);
+    if (record3 === void 0) continue;
+    args.reconstructed.set(key, { ...record3, fullData: packedBody });
+  }
+}
+function packedFoldSchemaV4(documents, base, projectId) {
+  const seedEnvelope = { projectId, createdAt: 0, updatedAt: 0 };
+  const completed = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    if (!isObjectRecord2(document.data)) continue;
+    const key = recordStateKey(document.recordKind, document.recordId);
+    const data = { ...document.data };
+    const envelope = {
+      ...seedEnvelope,
+      ...serverEnvelope(base[key]?.data)
+    };
+    for (const [field, value] of Object.entries(envelope)) {
+      if (data[field] === void 0) data[field] = value;
+    }
+    completed.set(key, data);
+  }
+  const memberRecords = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    if (document.recordKind !== "member") continue;
+    const data = completed.get(recordStateKey("member", document.recordId));
+    if (data !== void 0) memberRecords.set(document.recordId, data);
+  }
+  const classes = [];
+  const members = [];
+  const constructors = [];
+  const variants = [];
+  const variantFolders = [];
+  for (const document of documents) {
+    const data = completed.get(
+      recordStateKey(document.recordKind, document.recordId)
+    );
+    if (data === void 0) continue;
+    if (document.recordKind === "class") {
+      if (isNeoSchemaClass(data)) classes.push(data);
+    } else if (document.recordKind === "member") {
+      const member = hydrateProspectiveMemberOverride(data, memberRecords);
+      if (isMember(member)) members.push(member);
+    } else if (document.recordKind === "constructor") {
+      if (isNeoClassConstructor(data) || isUncompiledNeoClassConstructor(data)) {
+        constructors.push(data);
+      }
+    } else if (document.recordKind === "variant") {
+      if (isNeoClassVariant(data)) variants.push(data);
+    } else if (document.recordKind === "variant-folder") {
+      if (isNeoClassVariantFolder(data)) variantFolders.push(data);
+    }
+  }
+  return { classes, members, constructors, variants, variantFolders };
+}
 function hydrateProspectiveMemberOverride(data, members) {
   if (typeof data.extendsMemberId !== "string") {
     return data;
@@ -102805,6 +104607,7 @@ function hydrateProspectiveMemberOverride(data, members) {
     "modifier",
     "storage",
     "storageKey",
+    "distribution",
     "minValue",
     "maxValue",
     "decimalPoints",
@@ -103166,6 +104969,9 @@ var init_workspace_status_core = __esm({
     init_classes();
     init_members();
     init_value_row_owner_members();
+    init_constructors2();
+    init_packed_value_parity();
+    init_variants2();
     init_project2();
     init_project_version_types();
     init_instance_provenance();
@@ -104573,7 +106379,7 @@ function buildValueEmitContext(records2, manifest) {
     })
   );
   const classes = dataById(records2, "class");
-  const values = dataById(records2, "value");
+  const values = storedValueRowsByIdV4(records2.values());
   const enums = dataById(records2, "enum");
   const localizedTexts = dataById(records2, "localized-text");
   const dialogues = dataById(records2, "dialogue");
@@ -105678,6 +107484,7 @@ function variantRootMember(context, binding) {
     overrideOf: null,
     system: null,
     storage: "immutable",
+    distribution: null,
     storageKey: null
   };
 }
@@ -112834,6 +114641,16 @@ function listNeoWorkspaceFilesV1(root) {
 function listProjectSourceFilesV4(root) {
   return listNeoWorkspaceFilesV1(root).production;
 }
+function requiredProjectSourceKindV4(path) {
+  const kind = neoProjectSourceKind(path);
+  if (kind === null) {
+    throw new Error(`"${path}" is not a Neo project source path.`);
+  }
+  if (!isNeoProjectProductionSourceKind(kind)) {
+    throw new Error(`"${path}" is test-only source, not production source.`);
+  }
+  return kind;
+}
 function listProjectTestFilesV1(root) {
   return listNeoWorkspaceFilesV1(root).specs;
 }
@@ -116169,12 +117986,9 @@ function childStorageKeyDeclaration(args) {
 }
 function collectValueRows(records2) {
   const values = /* @__PURE__ */ new Map();
-  for (const record3 of Object.values(records2)) {
-    if (record3.recordKind !== "value") continue;
-    const data = record3.data;
-    if (!isObjectRecord2(data)) continue;
-    values.set(record3.recordId, {
-      id: record3.recordId,
+  for (const [valueId, data] of storedValueRowsByIdV4(Object.values(records2))) {
+    values.set(valueId, {
+      id: valueId,
       classId: typeof data.classId === "string" ? data.classId : null,
       mapKey: typeof data.mapKey === "string" ? data.mapKey : null,
       containerId: typeof data.containerId === "string" ? data.containerId : null,
@@ -119153,6 +120967,49 @@ var init_project_file_push = __esm({
   }
 });
 
+// ../src/database/packed-value-record-validation.ts
+function packedValueRecordViolation(row) {
+  if (!rowCarriesPackedValueContent(row)) return null;
+  let decoded;
+  try {
+    decoded = decodePackedValueRow(row);
+  } catch (error) {
+    if (error instanceof PackedValueEncodingError) return error.message;
+    throw error;
+  }
+  const rootViolation = decodedRowViolation(
+    decoded.row,
+    `distribution root "${decoded.row.id}"`
+  );
+  if (rootViolation !== null) return rootViolation;
+  for (const child of decoded.children) {
+    const childViolation = decodedRowViolation(
+      child,
+      `packed child "${child.id}"`
+    );
+    if (childViolation !== null) return childViolation;
+  }
+  return null;
+}
+function decodedRowViolation(row, label) {
+  if (!isMemberValue(row)) {
+    return `Decoded ${label} is not a valid value row.`;
+  }
+  const provenance = canonicalInstanceProvenanceViolation(row);
+  if (provenance !== null) {
+    return `Decoded ${label} violates canonical instance provenance: ${provenance}.`;
+  }
+  return null;
+}
+var init_packed_value_record_validation = __esm({
+  "../src/database/packed-value-record-validation.ts"() {
+    "use strict";
+    init_instance_provenance();
+    init_member_kinds();
+    init_packed_value_encoding();
+  }
+});
+
 // ../src/models/project-file-authoring-identifiers.ts
 function isValidProjectFileAuthoringIdentifier(value) {
   return isValidProjectSourceIdentifier(value);
@@ -119191,7 +121048,13 @@ function validateProjectRecordByKind(recordKind, data, options = {}) {
     if (memberGuard(data)) return;
   }
   if (recordKind === ProjectRecordKind.Value) {
-    if (isMemberValue(data)) return;
+    if (isMemberValue(data)) {
+      const packedViolation = packedValueRecordViolation(data);
+      if (packedViolation === null) return;
+      throw new Error(
+        `Value "${data.id}" carries an invalid packed subtree: ${packedViolation}`
+      );
+    }
   }
   if (recordKind === ProjectRecordKind.Class) {
     if (isNeoSchemaClass(data)) return;
@@ -119271,6 +121134,7 @@ var init_project_version_validation = __esm({
     init_classes();
     init_constructors2();
     init_inheritance();
+    init_packed_value_record_validation();
     init_generics();
     init_enum2();
     init_interfaces();
@@ -122295,8 +124159,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 4,
-      contractVersion: "4.0",
-      cliVersion: "0.40.0",
+      contractVersion: "4.1",
+      cliVersion: "0.41.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -122314,6 +124178,11 @@ var init_registry2 = __esm({
             "system",
             "storage",
             "storageKey",
+            // Deliberately carries no normalization rule (P76 §1): absence is the
+            // canonical automatic setting and explicit ordinal 0 is an explicit
+            // `.Sparse`, so `absentMeansDefault` would collapse the two states
+            // that the whole contract exists to keep apart.
+            "distribution",
             "minValue",
             "maxValue",
             "decimalPoints",
@@ -122638,6 +124507,7 @@ var init_registry2 = __esm({
             NeoListKind: ["Ordered", "Unordered"],
             NeoDictionaryKeyKind: ["String", "Enum"],
             NeoClassVisibility: ["Visible", "Hidden"],
+            NeoSubtreeDistribution: ["Sparse", "Packed"],
             NeoStringFormat: ["Localized", "Plain"],
             NeoMemberSearchBy: ["None", "MemberKey"],
             NeoListIndexKind: ["Bucket", "Unique"],
@@ -125521,7 +127391,7 @@ function inspectSourceContract(workspace) {
   try {
     const inputs = files.map((file, index) => ({
       uri: relativeFiles[index],
-      kind: requiredSourceKind(relativeFiles[index]),
+      kind: requiredProjectSourceKindV4(relativeFiles[index]),
       text: readFileSync17(file, "utf8")
     }));
     const analysis = compileNeoProjectSources(inputs);
@@ -125642,13 +127512,6 @@ function inspectTrackedBinary(root, record3, errors) {
     errors.push(`Tracked project file ${path} is not readable.`);
   }
 }
-function requiredSourceKind(path) {
-  const kind = neoProjectSourceKind(path);
-  if (kind !== null && isNeoProjectProductionSourceKind(kind)) return kind;
-  throw new Error(
-    `Unsupported Neo project source path ${JSON.stringify(path)}.`
-  );
-}
 function errorDiagnostics(diagnostics) {
   return diagnostics.filter(
     (diagnostic) => diagnostic.severity === "error" && !isPullRecoveryDiagnosticCode(diagnostic.code)
@@ -125769,6 +127632,440 @@ var init_doctor = __esm({
   }
 });
 
+// ../src/database/p76-canonical-value-id-plan.ts
+function rewriteP76CanonicalValueIds(args) {
+  if (args.newByOldValueId.size === 0) return args.data;
+  return rewriteRecord(args.recordKind, args.data, args.newByOldValueId);
+}
+function rewriteRecord(recordKind, data, newByOldValueId) {
+  if (!isPlainRecord5(data)) return data;
+  return mapRecord(data, (field, child) => {
+    if (field === "id") {
+      return recordKind === ProjectRecordKind.Value ? remap(child, newByOldValueId) : child;
+    }
+    if (field === "sourceValueId") return child;
+    if (ROW_CONTENT_FIELDS.has(field)) {
+      return rewriteRowContent(child, newByOldValueId);
+    }
+    if (isRelationEndpoint(recordKind, data, field)) {
+      return remap(child, newByOldValueId);
+    }
+    return rewriteByFieldName(child, field, newByOldValueId);
+  });
+}
+function isRelationEndpoint(recordKind, data, field) {
+  if (recordKind !== ProjectRecordKind.InternalRecordRelation) return false;
+  if (field === "sourceRecordId") {
+    return data.sourceRecordKind === ProjectRecordKind.Value;
+  }
+  if (field === "targetRecordId") {
+    return data.targetRecordKind === ProjectRecordKind.Value;
+  }
+  return false;
+}
+function rewriteRowContent(node, newByOldValueId) {
+  if (typeof node === "string") return remap(node, newByOldValueId);
+  if (Array.isArray(node)) {
+    return mapArray(node, (entry) => rewriteRowContent(entry, newByOldValueId));
+  }
+  if (!isPlainRecord5(node)) return node;
+  if (Object.hasOwn(node, STRUCTURED_LEAF_PARTIAL_KEY)) return node;
+  const packed = node[PACKED_VALUE_ENTRY_KEY];
+  if (packed !== void 0) {
+    const rewritten = rewritePackedEntry(packed, newByOldValueId);
+    if (rewritten === packed) return node;
+    return { ...node, [PACKED_VALUE_ENTRY_KEY]: rewritten };
+  }
+  return mapRecord(
+    node,
+    (_field, child) => rewriteRowContent(child, newByOldValueId)
+  );
+}
+function rewritePackedEntry(entry, newByOldValueId) {
+  if (!isPlainRecord5(entry)) return entry;
+  return mapRecord(entry, (field, child) => {
+    if (field === "id") return remap(child, newByOldValueId);
+    if (field === "sourceValueId") return child;
+    if (ROW_CONTENT_FIELDS.has(field)) {
+      return rewriteRowContent(child, newByOldValueId);
+    }
+    return rewriteByFieldName(child, field, newByOldValueId);
+  });
+}
+function rewriteByFieldName(node, field, newByOldValueId) {
+  if (typeof node === "string") {
+    if (isCompilerReferenceField(field)) return remap(node, newByOldValueId);
+    if (AUTHORED_VALUE_ID_FIELDS.has(field)) {
+      return remap(node, newByOldValueId);
+    }
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return mapArray(
+      node,
+      (entry) => rewriteByFieldName(entry, field, newByOldValueId)
+    );
+  }
+  if (!isPlainRecord5(node)) return node;
+  if (Object.hasOwn(node, STRUCTURED_LEAF_PARTIAL_KEY)) return node;
+  return mapRecord(node, (childField, child) => {
+    if (childField === "sourceValueId") return child;
+    if (ROW_CONTENT_FIELDS.has(childField)) {
+      return rewriteRowContent(child, newByOldValueId);
+    }
+    return rewriteByFieldName(child, childField, newByOldValueId);
+  });
+}
+function remap(node, newByOldValueId) {
+  if (typeof node !== "string") return node;
+  return newByOldValueId.get(node) ?? node;
+}
+function mapRecord(record3, rewrite) {
+  let changed = false;
+  const next = {};
+  for (const [field, child] of Object.entries(record3)) {
+    const rewritten = rewrite(field, child);
+    if (rewritten !== child) changed = true;
+    next[field] = rewritten;
+  }
+  return changed ? next : record3;
+}
+function mapArray(entries, rewrite) {
+  let changed = false;
+  const next = new Array(entries.length);
+  for (const [index, entry] of entries.entries()) {
+    const rewritten = rewrite(entry);
+    if (rewritten !== entry) changed = true;
+    next[index] = rewritten;
+  }
+  return changed ? next : entries;
+}
+function isPlainRecord5(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return !Array.isArray(value);
+}
+var P76_CANONICAL_VALUE_ID_USE_SITES, AUTHORED_VALUE_ID_FIELDS, ROW_CONTENT_FIELDS;
+var init_p76_canonical_value_id_plan = __esm({
+  "../src/database/p76-canonical-value-id-plan.ts"() {
+    "use strict";
+    init_inheritance();
+    init_instance_provenance();
+    init_member_kinds();
+    init_member_value_id();
+    init_packed_value_encoding();
+    init_stored_value_placement_index();
+    init_structured_leaf_fields();
+    init_project2();
+    init_neo_script_recompile_scope();
+    init_virtual_instance_values();
+    P76_CANONICAL_VALUE_ID_USE_SITES = [
+      "value.id",
+      "value.containerId",
+      "value.instanceVariantRowValueId",
+      "value.sourceValueId",
+      "value.constructorArgs.*",
+      "value.value.*",
+      `value.value.${PACKED_VALUE_ENTRY_KEY}.id`,
+      `value.value.${PACKED_VALUE_ENTRY_KEY}.value.*`,
+      `value.value.${PACKED_VALUE_ENTRY_KEY}.constructorArgs.*`,
+      `value.value.${PACKED_VALUE_ENTRY_KEY}.instanceVariantRowValueId`,
+      `value.value.${PACKED_VALUE_ENTRY_KEY}.sourceValueId`,
+      "value.init.**",
+      "member.valueId",
+      "member.collectionValueId",
+      "member.defaultValue.*",
+      "member.getter.**",
+      "member.setter.**",
+      "member.action.**",
+      "member.uiAction.**",
+      "variant.valueId",
+      "variant-folder.binding.collectionValueId",
+      "constructor.action.**",
+      "constructor.compiledBaseArguments.**",
+      "constructor.compiledBaseInitializerFields.**",
+      "dialogue.primaryLinkedValueId",
+      "dialogue.linkedValues.*.valueId",
+      "dialogue-node.primaryLinkedValueId",
+      "dialogue-node.linkedValues.*.valueId",
+      "dialogue-node.dialogueGroupSettings.lookupValueId",
+      "dialogue-node.**",
+      "dialogue-group.collectionValueId",
+      "dialogue-group.conditions.**",
+      "localized-text.links.*.valueId",
+      "internal-record-relation.sourceRecordId",
+      "internal-record-relation.targetRecordId"
+    ];
+    AUTHORED_VALUE_ID_FIELDS = /* @__PURE__ */ new Set([
+      "assetValueId",
+      "containerId",
+      "instanceVariantRowValueId",
+      "lookupValueId",
+      "rowValueId"
+    ]);
+    ROW_CONTENT_FIELDS = /* @__PURE__ */ new Set([
+      "value",
+      "constructorArgs"
+    ]);
+  }
+});
+
+// src/commands/migrate-rekey.ts
+import { readFileSync as readFileSync18, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join17, relative as relative8, sep as sep8 } from "node:path";
+import { ConvexError as ConvexError2 } from "convex/values";
+function rekeyCanonicalValueIdsInSource(text, newByOldValueId) {
+  let pins = 0;
+  let references = 0;
+  const pinned = text.replace(
+    ID_PIN_PATTERN,
+    (match, open, oldId, close) => {
+      const newId = newByOldValueId.get(oldId);
+      if (newId === void 0) return match;
+      pins += 1;
+      return `${open}${newId}${close}`;
+    }
+  );
+  const rewritten = pinned.replace(
+    REFERENCE_ID_PATTERN,
+    (match, open, oldId, close) => {
+      const newId = newByOldValueId.get(oldId);
+      if (newId === void 0) return match;
+      references += 1;
+      return `${open}${newId}${close}`;
+    }
+  );
+  return { text: rewritten, pins, references };
+}
+function assertNoOldValueIdsInSource(files, oldValueIds) {
+  for (const file of files) {
+    for (const match of file.text.matchAll(QUOTED_STRING_PATTERN)) {
+      const quoted = match[1];
+      if (quoted === void 0) continue;
+      if (!oldValueIds.has(quoted)) continue;
+      const line = file.text.slice(0, match.index).split("\n").length;
+      throw new Error(
+        `${file.path}:${String(line)} still quotes pre-migration value id "${quoted}" outside an @id pin or Reference(id:) literal. Rewrite that use by hand, then rerun "neo migrate rekey".`
+      );
+    }
+  }
+}
+function rekeyWorkspaceState(state, newByOldValueId) {
+  const nextRecords = {};
+  let recordsRekeyed = 0;
+  let recordsDataRewritten = 0;
+  for (const [key, record3] of Object.entries(state.records)) {
+    if (!isProjectRecordKind(record3.recordKind)) {
+      throw new Error(
+        `Workspace state entry "${key}" has unknown record kind "${record3.recordKind}".`
+      );
+    }
+    const data = rewriteP76CanonicalValueIds({
+      recordKind: record3.recordKind,
+      data: record3.data,
+      newByOldValueId
+    });
+    if (data !== record3.data) recordsDataRewritten += 1;
+    const newValueId = record3.recordKind === ProjectRecordKind.Value ? newByOldValueId.get(record3.recordId) : void 0;
+    if (newValueId === void 0) {
+      nextRecords[key] = { ...record3, data };
+      continue;
+    }
+    const nextKey = recordStateKey(record3.recordKind, newValueId);
+    if (Object.hasOwn(state.records, nextKey)) {
+      throw new Error(
+        `Workspace state entry "${key}" rekeys to "${nextKey}", which the working copy already tracks.`
+      );
+    }
+    if (Object.hasOwn(nextRecords, nextKey)) {
+      throw new Error(
+        `Workspace state entry "${key}" rekeys to "${nextKey}", which another entry already claimed.`
+      );
+    }
+    nextRecords[nextKey] = { ...record3, data, recordId: newValueId };
+    recordsRekeyed += 1;
+  }
+  state.records = nextRecords;
+  delete state.documentRevisionCursor;
+  delete state.headTransactionHash;
+  return { recordsRekeyed, recordsDataRewritten };
+}
+async function runMigrateRekey(workspace, dependencies = {}) {
+  const mappings = await (dependencies.fetchMappings ?? fetchCanonicalValueIdMappings)(workspace);
+  if (mappings.length === 0) {
+    console.log("Nothing to rekey.");
+    return;
+  }
+  const newByOldValueId = new Map(
+    mappings.map((mapping) => [mapping.oldValueId, mapping.newValueId])
+  );
+  const status = (dependencies.computeStatus ?? computeWorkspaceStatus2)(
+    workspace
+  );
+  if (status.conflictedFiles.length > 0) {
+    throw new Error(
+      `Resolve conflict markers before rekeying canonical value ids: ${status.conflictedFiles.join(", ")}`
+    );
+  }
+  for (const [key, record3] of Object.entries(workspace.state.records)) {
+    if (record3.conflictServerHash === void 0) continue;
+    throw new Error(
+      `Workspace state entry "${key}" holds an unresolved pull conflict; run "neo resolve" before rekeying canonical value ids.`
+    );
+  }
+  const rewrites = rewriteTrackedSources(workspace.root, newByOldValueId);
+  assertNoOldValueIdsInSource(
+    rewrites.map((rewrite) => ({
+      path: rewrite.path,
+      text: rewrite.text
+    })),
+    new Set(newByOldValueId.keys())
+  );
+  const changedFiles = rewrites.filter(
+    (rewrite) => rewrite.text !== rewrite.original
+  );
+  if (changedFiles.length > 0) {
+    assertRekeyedSourceCompiles(rewrites, newByOldValueId);
+  }
+  const stateResult = rekeyWorkspaceState(workspace.state, newByOldValueId);
+  if (changedFiles.length === 0 && stateResult.recordsRekeyed === 0 && stateResult.recordsDataRewritten === 0) {
+    console.log("Already rekeyed \u2014 no pre-migration value ids remain.");
+    return;
+  }
+  for (const rewrite of changedFiles) {
+    writeFileSync12(join17(workspace.root, rewrite.path), rewrite.text, "utf8");
+  }
+  writeWorkspaceState(workspace.root, workspace.state);
+  for (const path of DERIVED_CACHE_PATHS) {
+    rmSync8(join17(workspace.root, path), { force: true });
+  }
+  let pins = 0;
+  let references = 0;
+  for (const file of changedFiles) {
+    pins += file.pins;
+    references += file.references;
+  }
+  console.log(
+    `Rekeyed ${String(changedFiles.length)} source file(s): ${String(pins)} @id pin(s), ${String(references)} Reference(id:) literal(s).`
+  );
+  console.log(
+    `Rekeyed ${String(stateResult.recordsRekeyed)} state record(s) and rewrote ids in ${String(stateResult.recordsDataRewritten)}. Run "neo pull" next.`
+  );
+}
+function rewriteTrackedSources(root, newByOldValueId) {
+  const rewrites = [];
+  const collect = (absolutePaths, production) => {
+    for (const absolutePath of absolutePaths) {
+      const original = readFileSync18(absolutePath, "utf8");
+      rewrites.push({
+        path: relative8(root, absolutePath).split(sep8).join("/"),
+        original,
+        production,
+        ...rekeyCanonicalValueIdsInSource(original, newByOldValueId)
+      });
+    }
+  };
+  collect(listProjectSourceFilesV4(root), true);
+  collect(listProjectTestFilesV1(root), false);
+  return rewrites;
+}
+function assertRekeyedSourceCompiles(rewrites, newByOldValueId) {
+  const production = rewrites.filter((rewrite) => rewrite.production);
+  const inputs = production.map((rewrite) => ({
+    uri: rewrite.path,
+    kind: requiredProjectSourceKindV4(rewrite.path),
+    text: rewrite.original
+  }));
+  const before = new Set(
+    blockingDiagnostics(compileNeoProjectSources(inputs)).map(
+      (diagnostic) => diagnosticSignature(diagnostic, newByOldValueId)
+    )
+  );
+  const introduced = blockingDiagnostics(
+    compileNeoProjectSources(
+      inputs.map((input, index) => ({
+        ...input,
+        text: production[index].text
+      }))
+    )
+  ).filter(
+    (diagnostic) => !before.has(diagnosticSignature(diagnostic, newByOldValueId))
+  );
+  if (introduced.length === 0) return;
+  throw new Error(
+    `Canonical value-id rekey produced invalid source:
+${introduced.map(
+      (diagnostic) => `  ${diagnostic.uri}:${String(diagnostic.range.start.line + 1)}:${String(diagnostic.range.start.character + 1)} ${diagnostic.message}`
+    ).join("\n")}`
+  );
+}
+function blockingDiagnostics(analysis) {
+  return analysis.diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "error" && !isPullRecoveryDiagnosticCode(diagnostic.code)
+  );
+}
+function diagnosticSignature(diagnostic, newByOldValueId) {
+  const message = diagnostic.message.replace(
+    /[A-Za-z0-9_-]+/g,
+    (token) => newByOldValueId.get(token) ?? token
+  );
+  return `${diagnostic.uri} ${diagnostic.code ?? ""} ${message}`;
+}
+async function fetchCanonicalValueIdMappings(workspace) {
+  const convex = await createConvexClient(workspace);
+  const mappings = [];
+  let cursor = null;
+  for (; ; ) {
+    const page = await queryMappingsPage(convex, workspace, cursor);
+    for (const mapping of page.page) mappings.push(mapping);
+    if (page.isDone) break;
+    cursor = page.continueCursor;
+  }
+  return mappings;
+}
+async function queryMappingsPage(convex, workspace, cursor) {
+  try {
+    return await convex.query(
+      api2.projectDocuments.getCanonicalValueIdMappingsPage,
+      {
+        projectId: workspace.config.projectId,
+        versionId: workspace.config.versionId,
+        paginationOpts: { cursor, numItems: MAPPING_PAGE_SIZE }
+      }
+    );
+  } catch (error) {
+    if (error instanceof ConvexError2 && typeof error.data === "string") {
+      throw new Error(error.data);
+    }
+    throw error;
+  }
+}
+var MAPPING_PAGE_SIZE, ID_PIN_PATTERN, REFERENCE_ID_PATTERN, QUOTED_STRING_PATTERN, DERIVED_CACHE_PATHS;
+var init_migrate_rekey = __esm({
+  "src/commands/migrate-rekey.ts"() {
+    "use strict";
+    init_src();
+    init_p76_canonical_value_id_plan();
+    init_project2();
+    init_convex();
+    init_materialized_construction_cache();
+    init_project_document_cache();
+    init_project_documents();
+    init_source_diagnostics();
+    init_workspace_status();
+    init_workspace();
+    MAPPING_PAGE_SIZE = 512;
+    ID_PIN_PATTERN = /(@id\s*\(\s*")([^"]*)("\s*\))/g;
+    REFERENCE_ID_PATTERN = /(Reference\s*\(\s*id\s*:\s*")([^"]*)(")/g;
+    QUOTED_STRING_PATTERN = /"([^"\n]*)"/g;
+    DERIVED_CACHE_PATHS = [
+      PROJECT_SOURCE_ANALYSIS_V4_CACHE_PATH,
+      PROJECT_SOURCE_BUILD_CACHE_PATH,
+      PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH,
+      MATERIALIZED_CONSTRUCTION_BUILD_CACHE_PATH
+    ];
+  }
+});
+
 // src/commands/migrate.ts
 var migrate_exports = {};
 __export(migrate_exports, {
@@ -125779,8 +128076,8 @@ __export(migrate_exports, {
   runMigrate: () => runMigrate
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync12, readdirSync as readdirSync6, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join18 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
     const name = positional[0];
@@ -125789,7 +128086,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
         "Usage: neo migrate new <name> [--target <ClassName|project>]"
       );
     }
-    const migrationsDir = join17(workspace.root, "Migrations");
+    const migrationsDir = join18(workspace.root, "Migrations");
     mkdirSync12(migrationsDir, { recursive: true });
     let nextOrder = 1;
     if (existsSync15(migrationsDir)) {
@@ -125801,7 +128098,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       }
     }
     const relPath = migrationFileName(nextOrder, name);
-    const absolute = join17(workspace.root, relPath);
+    const absolute = join18(workspace.root, relPath);
     if (existsSync15(absolute)) {
       throw new Error(`"${relPath}" already exists.`);
     }
@@ -125813,11 +128110,18 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       target === "project" ? "// Runs once with root context. Write the NeoScript action below." : `// Runs once per ${target} value; \`this\` is the instance.`,
       ""
     ].join("\n");
-    writeFileSync12(absolute, template, "utf8");
+    writeFileSync13(absolute, template, "utf8");
     console.log(`Created ${relPath} \u2014 edit the action body, then "neo push".`);
     console.log("(The id is assigned at push, same as schema creates.)");
     return;
   }
+  if (subcommand === "rekey") {
+    await runMigrateRekey(workspace, {
+      ...dependencies.fetchCanonicalValueIdMappings === void 0 ? {} : { fetchMappings: dependencies.fetchCanonicalValueIdMappings },
+      ...dependencies.computeStatus === void 0 ? {} : { computeStatus: dependencies.computeStatus }
+    });
+    return;
+  }
   const { raw } = await (dependencies.fetchDocument ?? fetchProjectDocument)(
     workspace
   );
@@ -126940,6 +129244,7 @@ var init_migrate = __esm({
     init_virtual_instance_values();
     init_script();
     init_project_migration_created_values();
+    init_migrate_rekey();
   }
 });
 
@@ -127552,7 +129857,7 @@ __export(content_exports, {
   makeContentContext: () => makeContentContext,
   runLoc: () => runLoc
 });
-import { readFileSync as readFileSync18 } from "node:fs";
+import { readFileSync as readFileSync19 } from "node:fs";
 import { randomUUID as randomUUID5 } from "node:crypto";
 function versionPath2(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
@@ -127560,9 +129865,9 @@ function versionPath2(workspace, suffix) {
 function readBatch(file) {
   let raw = null;
   if (file !== null) {
-    raw = readFileSync18(file, "utf8");
+    raw = readFileSync19(file, "utf8");
   } else if (!process.stdin.isTTY) {
-    raw = readFileSync18(0, "utf8");
+    raw = readFileSync19(0, "utf8");
     if (raw.trim().length === 0) raw = null;
   }
   if (raw === null) return null;
@@ -128594,8 +130899,8 @@ var export_exports = {};
 __export(export_exports, {
   runExportUnity: () => runExportUnity
 });
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join19 } from "node:path";
 async function runExportUnity(workspace, outDir) {
   if (outDir === null) {
     throw new Error(
@@ -128607,23 +130912,23 @@ async function runExportUnity(workspace, outDir) {
     `/api/projects/${workspace.config.projectId}/export`,
     { versionId: workspace.config.versionId }
   );
-  const resourcesDir = join18(outDir, "Resources", "Neo");
-  const localizationDir = join18(resourcesDir, "Localization");
-  const scriptsDir = join18(outDir, "Scripts", "Neo");
+  const resourcesDir = join19(outDir, "Resources", "Neo");
+  const localizationDir = join19(resourcesDir, "Localization");
+  const scriptsDir = join19(outDir, "Scripts", "Neo");
   mkdirSync13(localizationDir, { recursive: true });
   mkdirSync13(scriptsDir, { recursive: true });
-  writeFileSync13(join18(resourcesDir, "project.json"), response.projectJson);
-  writeFileSync13(
-    join18(scriptsDir, "NeoGeneratedTypes.cs"),
+  writeFileSync14(join19(resourcesDir, "project.json"), response.projectJson);
+  writeFileSync14(
+    join19(scriptsDir, "NeoGeneratedTypes.cs"),
     response.generatedTypes
   );
   for (const file of response.localizationFiles ?? []) {
-    writeFileSync13(join18(localizationDir, file.fileName), file.content);
+    writeFileSync14(join19(localizationDir, file.fileName), file.content);
   }
-  console.log(`wrote ${join18(resourcesDir, "project.json")}`);
-  console.log(`wrote ${join18(scriptsDir, "NeoGeneratedTypes.cs")}`);
+  console.log(`wrote ${join19(resourcesDir, "project.json")}`);
+  console.log(`wrote ${join19(scriptsDir, "NeoGeneratedTypes.cs")}`);
   for (const file of response.localizationFiles ?? []) {
-    console.log(`wrote ${join18(localizationDir, file.fileName)}`);
+    console.log(`wrote ${join19(localizationDir, file.fileName)}`);
   }
   const diagnostics = response.diagnostics ?? [];
   for (const diagnostic of diagnostics) {
@@ -128646,7 +130951,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -128756,7 +131061,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join19(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join20(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -128811,16 +131116,16 @@ __export(resolve_exports, {
   runResolve: () => runResolve,
   workspaceFilePath: () => workspaceFilePath
 });
-import { readFileSync as readFileSync19, rmSync as rmSync8, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join20 } from "node:path";
+import { readFileSync as readFileSync20, rmSync as rmSync9, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join21 } from "node:path";
 function runResolve(workspace, side) {
   const resolvedRecords = adoptServerConflictBases(workspace);
   let resolvedFiles = 0;
   for (const filePath of listProjectSourceFilesV4(workspace.root)) {
-    const source = readFileSync19(filePath, "utf8");
+    const source = readFileSync20(filePath, "utf8");
     if (detectConflictMarkers(source) === null) continue;
     const resolved = resolveMarkers(source, side);
-    writeFileSync14(filePath, resolved, "utf8");
+    writeFileSync15(filePath, resolved, "utf8");
     resolvedFiles += 1;
   }
   let resolvedBinaries = 0;
@@ -128828,22 +131133,22 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join20(workspace.root, binary.path);
+    const destination = join21(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync19(join20(workspace.root, conflict2.artifactPath)),
+          readFileSync20(join21(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
       } else {
-        rmSync8(destination, { force: true });
+        rmSync9(destination, { force: true });
         binary.sha256 = null;
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync8(join20(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync9(join21(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -128912,7 +131217,7 @@ function resolveMarkers(source, side) {
   return output.join("\n");
 }
 function workspaceFilePath(workspace, file) {
-  return join20(workspace.root, file);
+  return join21(workspace.root, file);
 }
 var init_resolve = __esm({
   "src/commands/resolve.ts"() {
@@ -128983,7 +131288,7 @@ ${h("Content & scripts")}
   loc       ${d("locales | list | set | create | delete | archive | restore | ...")}
   dialogue  ${d("dryrun <ref> [--json]")}
   script    ${d("check | eval | compile [--mode getter|action|setter|nsfunction] [--member <id-or-name>]")}
-  migrate   ${d("new | list | check | run | prune")}
+  migrate   ${d("new | list | check | run | prune | rekey")}
   export    ${d("unity [--out <path>]")}
 
 Run any command with missing arguments in a terminal and ${h("neo")} will ask.
@@ -129117,7 +131422,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.40.0");
+    console.log("0.41.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -129234,7 +131539,7 @@ async function main() {
       const sub = args.positional[0];
       if (sub === void 0) {
         throw new Error(
-          "neo migrate requires a subcommand: new | list | check | run."
+          "neo migrate requires a subcommand: new | list | check | run | prune | rekey."
         );
       }
       const { runMigrate: runMigrate2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));