@neocompose/cli 0.75.2 → 0.76.1

package/dist/test-worker.mjs

@@ -5295,6 +5295,9 @@ var ProjectSchemaIndex = class {
     for (const schemaClass2 of source.classes) {
       this.classesById.set(schemaClass2.id, schemaClass2);
       append(this.classesByName, schemaClass2.name, schemaClass2);
+      if (schemaClass2.extendsClassId) {
+        append(this.subclassesById, schemaClass2.extendsClassId, schemaClass2);
+      }
       for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
         append(this.schemaPlacementsByMemberId, memberId, {
           ownerClass: schemaClass2,
@@ -5339,6 +5342,8 @@ var ProjectSchemaIndex = class {
   source;
   classesById = /* @__PURE__ */ new Map();
   classesByName = /* @__PURE__ */ new Map();
+  /** Direct subclasses by the class they extend. */
+  subclassesById = /* @__PURE__ */ new Map();
   membersById = /* @__PURE__ */ new Map();
   membersByName = /* @__PURE__ */ new Map();
   enumsById = /* @__PURE__ */ new Map();
@@ -5523,6 +5528,9 @@ function indexSchema(classes, members) {
 function classIndexFor(classes) {
   return indexClasses(classes).classesById;
 }
+function subclassIndexFor(classes) {
+  return indexClasses(classes).subclassesById;
+}
 function memberIndexFor(members) {
   return projectSchemaIndexFor({ classes: NO_CLASSES, members }).membersById;
 }
@@ -5601,11 +5609,8 @@ function resolvedClassSchemaFromIndexes(classId, classIndex, memberIndex) {
   if (cached !== void 0) return cached;
   const chain = resolveChainFromIndex(classId, classIndex);
   const surface = [];
-  const stored = [];
-  const readOnly = [];
   const statics = [];
   const surfaceByKey = /* @__PURE__ */ new Map();
-  const storedByKey = /* @__PURE__ */ new Map();
   for (const entry of mergeSchemas(chain)) {
     const member = memberIndex.get(entry.memberId);
     if (member !== void 0 && isStaticMember(member)) {
@@ -5614,20 +5619,8 @@ function resolvedClassSchemaFromIndexes(classId, classIndex, memberIndex) {
     }
     surface.push(entry);
     surfaceByKey.set(entry.schemaKey, entry);
-    if (member !== void 0 && isReadOnlyMember(member)) readOnly.push(entry);
-    else {
-      stored.push(entry);
-      storedByKey.set(entry.schemaKey, entry);
-    }
   }
-  const node = {
-    surface,
-    stored,
-    readOnly,
-    statics,
-    surfaceByKey,
-    storedByKey
-  };
+  const node = { surface, statics, surfaceByKey };
   byClass.set(classId, node);
   return node;
 }
@@ -5647,9 +5640,6 @@ function mergeInstanceSurfaceSchemaFromIndexes(classId, classIndex, memberIndex)
     ...resolvedClassSchemaFromIndexes(classId, classIndex, memberIndex).surface
   ];
 }
-function mergeStoredInstanceSchema(classId, classes, members) {
-  return [...resolvedClassSchema(classId, classes, members).stored];
-}
 function findSchemaPlacement(memberId, classes) {
   return indexClasses(classes).firstSchemaPlacement(memberId);
 }
@@ -5742,15 +5732,7 @@ function resolveMemberWithIndex(member, memberIndex) {
   return Object.freeze(merged);
 }
 function descendantClassIds(classId, allClasses) {
-  const childrenByClassId = /* @__PURE__ */ new Map();
-  for (const schemaClass2 of allClasses) {
-    if (!schemaClass2.extendsClassId) continue;
-    const children = childrenByClassId.get(schemaClass2.extendsClassId);
-    if (children === void 0) {
-      childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2]);
-    } else children.push(schemaClass2);
-  }
-  return descendantClassIdsInChildIndex(classId, childrenByClassId);
+  return descendantClassIdsInChildIndex(classId, subclassIndexFor(allClasses));
 }
 function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   const result = /* @__PURE__ */ new Set();
@@ -5766,6 +5748,46 @@ function descendantClassIdsInChildIndex(classId, childrenByClassId) {
   return result;
 }
 
+// ../packages/models/src/members/instance-provenance.ts
+var LITERAL_INSTANCE_IDENTITY_FIELDS = [
+  "classId",
+  "constructorArgs",
+  "instanceConstructorId",
+  "instanceVariantId",
+  "instanceVariantRowValueId",
+  "genericBindings"
+];
+function replaceLiteralValueClass(value, classId) {
+  const next = { ...value, classId };
+  for (const field of LITERAL_INSTANCE_IDENTITY_FIELDS) {
+    if (field !== "classId") Reflect.deleteProperty(next, field);
+  }
+  return next;
+}
+function overlayLiteralValueContent(base, override) {
+  const merged = { ...base, ...override };
+  if (!("value" in override) || override.value !== null) return merged;
+  for (const field of LITERAL_INSTANCE_IDENTITY_FIELDS) {
+    if (!Object.hasOwn(override, field)) Reflect.deleteProperty(merged, field);
+  }
+  return merged;
+}
+function pickInstanceProvenance(source) {
+  return {
+    ...source.constructorArgs === void 0 ? {} : { constructorArgs: source.constructorArgs },
+    ...source.instanceConstructorId === void 0 ? {} : { instanceConstructorId: source.instanceConstructorId },
+    ...source.instanceVariantId === void 0 ? {} : { instanceVariantId: source.instanceVariantId },
+    ...source.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: source.instanceVariantRowValueId }
+  };
+}
+function isVirtualInstanceRootShape(value) {
+  if (value.instanceConstructorId !== void 0) return true;
+  return typeof value.instanceVariantId === "string";
+}
+function isCollapseStampedInstanceRoot(value) {
+  return isLiteralValueContent(value) && isVirtualInstanceRootShape(value);
+}
+
 // ../packages/models/src/system-record-id.ts
 var SYSTEM_RECORD_ID_PREFIX = "system_";
 function isSystemRecordId(id) {
@@ -5806,46 +5828,638 @@ function inSystemRecordNamespaceOf(ownerId, derivedId) {
   return systemRecordId(derivedId);
 }
 
-// ../packages/models/src/classes/world-system-classes.generated.ts
-var WORLD_SPRITE_MASK_INTERACTION_ENUM_ID = "system_4e6c4d6f-1d0b-402a-ad3a-be92242dceec";
-var WORLD_SPRITE_MASK_INTERACTION_NONE_OPTION_ID = "system_9d607a4f-60c3-4347-94fc-f24b538bf468";
-var WORLD_SPRITE_MASK_INTERACTION_VISIBLE_INSIDE_OPTION_ID = "system_4c670ac9-78a4-44e9-9833-94e1c69dca97";
-var WORLD_SPRITE_MASK_INTERACTION_VISIBLE_OUTSIDE_OPTION_ID = "system_a0aeb200-7216-49e2-aad2-e151ff35c336";
-var WORLD_ANIMATION_CHILD_OVERRIDE_ENTRY_PARAM_ID = "system_de23448a-45be-4e3f-8965-072a545e08f0";
-var WORLD_ANIMATION_FRAME_OVERRIDES_MEMBER_ID = "system_8ab7bb00-a475-43f0-8579-1b08f133d658";
-var WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID = "system_a5905750-c472-46a8-89e9-f04f0bf66696";
-var WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_ENTRY_MEMBER_ID = "system_86688965-6b26-529e-95f3-a4070f022582";
-var WORLD_ANIMATION_CHILD_OVERRIDE_OVERRIDES_MEMBER_ID = "system_819b3743-0c3d-4896-b679-9aeeb73255f4";
-var WORLD_PLAY_DIRECTION_ENUM_ID = "system_705ccc39-e46e-4c9f-af3e-3ec8fd818709";
-var WORLD_PLAY_DIRECTION_FORWARD_OPTION_ID = "system_2e4ca40e-f305-49c6-a91b-b99d56239ba0";
-var WORLD_PLAY_DIRECTION_REVERSE_OPTION_ID = "system_6478d195-3905-48db-befe-d276eb5478f0";
-var WORLD_SYSTEM_CLASS_DEFINITIONS = [
-  {
-    classId: "system_fb9c4080-0148-530e-b9c0-8cd1c17ff8e7",
-    name: "NeoCellPattern",
-    docsText: "An immutable ordered pattern of cell offsets, relative to an origin.\nHand-built patterns preserve order and duplicates; factories order cells nearest first.",
-    modifier: 2 /* Sealed */,
-    constructorIds: ["system_f68684d6-6ea0-5d57-9f96-d544b17bf369"],
-    constructors: [
-      {
-        constructorId: "system_f68684d6-6ea0-5d57-9f96-d544b17bf369",
-        argumentTypes: [
-          {
-            name: "offsets",
-            type: 6,
-            required: true,
-            entryTypeInfo: { type: 15, required: true }
-          }
-        ],
-        code: "this._offsets = offsets.Select((offset) => { return Vector2Int(offset.x, offset.y); });"
+// ../packages/models/src/members/member-value-id.ts
+var NEO_MEMBER_VALUE_NAMESPACE = "7f2b9c14-58d6-5a07-b3e1-4c9d0a6f8b25";
+var NEO_VIRTUAL_VALUE_NAMESPACE = "3e8ca0b3-e3f1-5d5f-bf2f-6ab5ee3896d0";
+var virtualNamespaceBytes = parse_default(NEO_VIRTUAL_VALUE_NAMESPACE);
+var virtualIdentityEncoder = new TextEncoder();
+var SURROGATE_CODE_UNIT = /[\ud800-\udfff]/;
+function derivedMemberValueId(memberId) {
+  return inSystemRecordNamespaceOf(
+    memberId,
+    v5_default(withoutSystemRecordIdPrefix(memberId), NEO_MEMBER_VALUE_NAMESPACE)
+  );
+}
+function virtualValueId(instanceRootId, sourceIdentity2) {
+  const identity = `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity2}`;
+  const bytes = SURROGATE_CODE_UNIT.test(identity) ? identity : virtualIdentityEncoder.encode(identity);
+  return inSystemRecordNamespaceOf(
+    instanceRootId,
+    v5_default(bytes, virtualNamespaceBytes)
+  );
+}
+function virtualSourceIdentityHead(sourceIdentity2) {
+  const pathStart = sourceIdentity2.indexOf(":$");
+  return pathStart < 0 ? sourceIdentity2 : sourceIdentity2.slice(0, pathStart);
+}
+function hasPendingVirtualSourceIdentity(sourceIdentity2) {
+  const head = virtualSourceIdentityHead(sourceIdentity2);
+  return head.startsWith("path:__pending__:") || head.startsWith("__pending__:");
+}
+var PENDING_VIRTUAL_VALUE_PREFIX = "__pending__:virtual-value:";
+function pendingVirtualValueId(pendingInstanceRootId, sourceIdentity2) {
+  return `${PENDING_VIRTUAL_VALUE_PREFIX}${encodeURIComponent(pendingInstanceRootId)}:${encodeURIComponent(sourceIdentity2)}`;
+}
+
+// ../packages/models/src/members/packed-value-encoding.ts
+var PACKED_VALUE_ENTRY_KEY = "~packed";
+var PackedValueEncodingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PackedValueEncodingError";
+  }
+};
+var NO_CHILDREN = [];
+var NO_EDGES = /* @__PURE__ */ new Map();
+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(document2) {
+  const stored = document2.values;
+  const expanded = expandPackedValueRows(stored);
+  if (expanded === stored) return document2;
+  return { ...document2, 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 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 id = packedEntryLogicalId(entry, label, scope.constructionRootId);
+  if (scope.state.seenIds.has(id)) {
+    throw new PackedValueEncodingError(
+      `${label} resolves to id "${id}", which another row in the same packed payload already claims.`
+    );
+  }
+  scope.state.seenIds.add(id);
+  registerEdge(scope.state.edges, scope.ownerId, id);
+  const childScope = {
+    state: scope.state,
+    ownerId: id,
+    ownerLabel: `packed value "${id}"`,
+    constructionRootId: isCollapseStampedInstanceRoot(entry) ? id : scope.constructionRootId
+  };
+  const nested = [];
+  children.push(logicalChildRow(entry, id, childScope, nested));
+  children.push(...nested);
+  return id;
+}
+function logicalChildRow(entry, id, scope, children) {
+  const rowFields = {
+    id,
+    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;
+}
+var PACKED_ENTRY_FORBIDDEN_FIELDS = [
+  "projectId",
+  "containerId",
+  "mapKey"
+];
+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 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);
+}
+
+// ../packages/models/src/members/unordered-list-membership.ts
+function buildUnorderedListMembershipIndex(values) {
+  const membersByContainerId = /* @__PURE__ */ new Map();
+  for (const candidate of values) {
+    const containerId = candidate.containerId;
+    if (typeof containerId !== "string") continue;
+    const bucket = membersByContainerId.get(containerId);
+    if (bucket === void 0) {
+      membersByContainerId.set(containerId, [candidate.id]);
+    } else {
+      bucket.push(candidate.id);
+    }
+  }
+  for (const bucket of membersByContainerId.values()) {
+    bucket.sort();
+  }
+  return membersByContainerId;
+}
+
+// ../packages/models/src/members/member-storage-key.ts
+var MAIN_STORAGE_PARTITION = "main";
+var STORAGE_KEY_INHERIT = "inherit";
+var STORAGE_KEY_ALL = "all";
+var PARENT_CLASS_TEMPLATE_TOKEN = "$parentClass";
+function normalizeStorageKeyDeclaration(declaration) {
+  if (declaration === void 0 || declaration === null) {
+    return STORAGE_KEY_INHERIT;
+  }
+  if (declaration.length === 0) return STORAGE_KEY_INHERIT;
+  if (declaration === STORAGE_KEY_ALL) {
+    throw new Error(
+      'Storage key "all" is reserved for partition-scoped reads and cannot be declared on a member.'
+    );
+  }
+  return declaration;
+}
+function storageKeyReferencesParentClass(declaration) {
+  return declaration.includes(PARENT_CLASS_TEMPLATE_TOKEN);
+}
+function resolveMapKeyForCreatedValue(args) {
+  const declaration = normalizeStorageKeyDeclaration(args.declaration);
+  if (declaration === STORAGE_KEY_INHERIT) return args.parentMapKey;
+  if (declaration === MAIN_STORAGE_PARTITION) return null;
+  if (storageKeyReferencesParentClass(declaration)) {
+    if (args.parentClassId === void 0) {
+      throw new Error(
+        `Storage key "${declaration}" references ${PARENT_CLASS_TEMPLATE_TOKEN}, but the placement parent value has no classId (only class-valued parents can anchor a ${PARENT_CLASS_TEMPLATE_TOKEN} partition).`
+      );
+    }
+    return declaration.replaceAll(
+      PARENT_CLASS_TEMPLATE_TOKEN,
+      args.parentClassId
+    );
+  }
+  return declaration;
+}
+
+// ../packages/models/src/members/storage-partitions.ts
+function stampCreatedValuesMapKey(values, mapKey) {
+  const normalized = mapKey === void 0 || mapKey === null || mapKey.length === 0 || mapKey === MAIN_STORAGE_PARTITION ? null : mapKey;
+  for (const value of values) {
+    if (normalized === null) {
+      delete value.mapKey;
+    } else {
+      value.mapKey = normalized;
+    }
+  }
+}
+function applyDeclaredStorageKeyOverrides(args) {
+  const boundaryValues = args.createdValues.filter(
+    (value) => normalizeStorageKeyDeclaration(
+      args.declarationByValueId.get(value.id)
+    ) !== STORAGE_KEY_INHERIT
+  );
+  if (boundaryValues.length === 0) return;
+  const createdById = new Map(
+    args.createdValues.map((value) => [value.id, value])
+  );
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const value of args.createdValues) {
+    for (const childId of referencedValueIdCandidates(value.value)) {
+      if (createdById.has(childId)) parentOf.set(childId, value);
+    }
+  }
+  for (const value of args.createdValues) {
+    if (typeof value.containerId !== "string") continue;
+    const container = createdById.get(value.containerId);
+    if (container !== void 0) parentOf.set(value.id, container);
+  }
+  const depthOf = (value) => {
+    let depth = 0;
+    let current = value;
+    const seen = /* @__PURE__ */ new Set();
+    while (current !== void 0 && !seen.has(current.id)) {
+      seen.add(current.id);
+      current = parentOf.get(current.id);
+      if (current !== void 0) depth += 1;
+    }
+    return depth;
+  };
+  const boundaries = boundaryValues.sort((left, right) => depthOf(left) - depthOf(right));
+  for (const boundary of boundaries) {
+    const parentCreated = parentOf.get(boundary.id);
+    const parent = parentCreated !== void 0 ? {
+      mapKey: parentCreated.mapKey ?? null,
+      classId: parentCreated.classId ?? void 0
+    } : args.existingParentContextById?.get(boundary.id);
+    if (parent === void 0) {
+      throw new Error(
+        `Cannot resolve storage partition for created value "${boundary.id}": its placement parent is neither a created value nor supplied in existingParentContextById.`
+      );
+    }
+    const mapKey = resolveMapKeyForCreatedValue({
+      declaration: args.declarationByValueId.get(boundary.id),
+      parentMapKey: parent.mapKey,
+      parentClassId: parent.classId
+    });
+    for (const member of collectCreatedSubtreeValues(
+      boundary,
+      args.createdValues
+    )) {
+      if (mapKey === null || mapKey === MAIN_STORAGE_PARTITION) {
+        delete member.mapKey;
+      } else {
+        member.mapKey = mapKey;
       }
-    ],
-    schemaFields: [
-      {
-        memberId: "system_02a01003-41ff-531c-a63c-1e905ca88d7d",
-        memberKind: "list",
-        access: 2 /* Private */,
-        modifier: 1 /* Sealed */,
+    }
+  }
+}
+function collectCreatedSubtreeValues(root, createdValues) {
+  const createdById = new Map(createdValues.map((value) => [value.id, value]));
+  const subtree = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [root];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    if (visited.has(current.id)) continue;
+    visited.add(current.id);
+    subtree.push(current);
+    for (const childId of referencedValueIdCandidates(current.value)) {
+      const child = createdById.get(childId);
+      if (child !== void 0) queue.push(child);
+    }
+    for (const candidate of createdValues) {
+      if (candidate.containerId === current.id) queue.push(candidate);
+    }
+  }
+  return subtree;
+}
+function referencedValueIdCandidates(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => typeof entry === "string");
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.values(value).filter(
+      (entry) => typeof entry === "string"
+    );
+  }
+  return [];
+}
+
+// ../packages/models/src/core/auth-ownership-types.ts
+var ActorKind = {
+  /**
+   * `better-auth` user identities.
+   */
+  user: "user",
+  /**
+   * `better-auth` organization identities.
+   */
+  organization: "organization",
+  /**
+   * Used for denoting records created by a system.
+   */
+  system: "system"
+};
+function isActorIdentifier(value) {
+  if (typeof value !== "object") return false;
+  if (value === null) return false;
+  const candidate = value;
+  if (!isActorKind(candidate.kind)) return false;
+  return typeof candidate.id === "string" && candidate.id.trim().length > 0;
+}
+function isActorKind(value) {
+  return value === ActorKind.user || value === ActorKind.organization || value === ActorKind.system;
+}
+
+// ../packages/models/src/members/member-change-listeners.ts
+function editChangeListenerSet(explicit, inherited, edit, options = { inheritedComplete: true }) {
+  if (edit.kind === "reset") {
+    return explicit === void 0 ? { changed: false } : { changed: true, targets: void 0 };
+  }
+  const current = explicit ?? inherited;
+  let next;
+  if (edit.kind === "replace") {
+    next = edit.targets;
+  } else {
+    const identity = nsActionListenerIdentity(edit.target);
+    const index = current.findIndex(
+      (target) => nsActionListenerIdentity(target) === identity
+    );
+    if (edit.kind === "add") {
+      if (index !== -1) return { changed: false };
+      next = [...current, edit.target];
+    } else {
+      if (index === -1) return { changed: false };
+      next = current.filter((_, i) => i !== index);
+    }
+  }
+  const targets = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of next) {
+    const identity = nsActionListenerIdentity(target);
+    if (seen.has(identity))
+      throw new Error("A listener set cannot repeat a handler identity.");
+    seen.add(identity);
+    targets.push({ memberId: target.memberId, valueId: target.valueId });
+  }
+  if (targets.length === 0 && inherited.length === 0 && options.inheritedComplete) {
+    return explicit === void 0 ? { changed: false } : { changed: true, targets: void 0 };
+  }
+  if (explicit !== void 0 && sameChangeListeners(explicit, targets))
+    return { changed: false };
+  return { changed: true, targets };
+}
+function sameChangeListeners(left, right) {
+  return left.length === right.length && left.every(
+    (entry, index) => entry.memberId === right[index].memberId && entry.valueId === right[index].valueId
+  );
+}
+function remapChangeListenerMap(map, identities, policy, internalEndpoints) {
+  if (!map) return void 0;
+  const result = {};
+  for (const [ownerId, members] of Object.entries(map)) {
+    const owner = identities.get(ownerId);
+    if (owner === void 0) continue;
+    const entry = {};
+    for (const [memberId, targets] of Object.entries(members)) {
+      const remapped = [];
+      for (const target of targets) {
+        const receiver = target.valueId === null ? null : identities.get(target.valueId);
+        if (receiver === void 0 && (policy === "clone" || target.valueId !== null && internalEndpoints !== void 0 && internalEndpoints.has(target.valueId)))
+          continue;
+        remapped.push({
+          memberId: target.memberId,
+          valueId: receiver ?? target.valueId
+        });
+      }
+      setOwnField(entry, memberId, remapped);
+    }
+    setOwnField(result, owner, entry);
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+}
+var authoredListenerIndexes = /* @__PURE__ */ new WeakMap();
+function authoredChangeListenerOwners(rows) {
+  const index = authoredListenerIndexes.get(rows);
+  if (index !== void 0) return index;
+  const owners = /* @__PURE__ */ new Map();
+  for (const row of rows)
+    for (const [ownerId, entry] of Object.entries(row.changeListeners ?? {})) {
+      if (owners.has(ownerId))
+        throw new Error(
+          `Listener owner "${ownerId}" is declared on more than one binding root.`
+        );
+      owners.set(ownerId, entry);
+    }
+  authoredListenerIndexes.set(rows, owners);
+  return owners;
+}
+var declarationListenerMetadata = /* @__PURE__ */ new WeakMap();
+function hasAuthoredChangeListenerMetadata(document2) {
+  if (authoredChangeListenerOwners(document2.values).size !== 0) return true;
+  let present = declarationListenerMetadata.get(document2.members);
+  if (present === void 0) {
+    present = document2.members.some(
+      (member) => member.defaultValue?.changeListeners !== void 0
+    );
+    declarationListenerMetadata.set(document2.members, present);
+  }
+  return present;
+}
+function defaultSourceWithListeners(row, graph) {
+  if (row === null || graph == null || graph.instanceRootId !== row.id)
+    return row;
+  const inherited = graph.listenerDefaultsByOwner;
+  if (inherited === void 0 || inherited.size === 0) return row;
+  const map = Object.fromEntries(inherited);
+  for (const [id, entry] of Object.entries(row.changeListeners ?? {}))
+    setOwnField(map, id, { ...map[id], ...entry });
+  return { ...row, changeListeners: map };
+}
+
+// ../packages/models/src/classes/world-system-classes.generated.ts
+var WORLD_SPRITE_MASK_INTERACTION_ENUM_ID = "system_4e6c4d6f-1d0b-402a-ad3a-be92242dceec";
+var WORLD_SPRITE_MASK_INTERACTION_NONE_OPTION_ID = "system_9d607a4f-60c3-4347-94fc-f24b538bf468";
+var WORLD_SPRITE_MASK_INTERACTION_VISIBLE_INSIDE_OPTION_ID = "system_4c670ac9-78a4-44e9-9833-94e1c69dca97";
+var WORLD_SPRITE_MASK_INTERACTION_VISIBLE_OUTSIDE_OPTION_ID = "system_a0aeb200-7216-49e2-aad2-e151ff35c336";
+var WORLD_ANIMATION_CHILD_OVERRIDE_ENTRY_PARAM_ID = "system_de23448a-45be-4e3f-8965-072a545e08f0";
+var WORLD_ANIMATION_FRAME_OVERRIDES_MEMBER_ID = "system_8ab7bb00-a475-43f0-8579-1b08f133d658";
+var WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_MEMBER_ID = "system_a5905750-c472-46a8-89e9-f04f0bf66696";
+var WORLD_ANIMATION_FRAME_CHILD_OVERRIDES_ENTRY_MEMBER_ID = "system_86688965-6b26-529e-95f3-a4070f022582";
+var WORLD_ANIMATION_CHILD_OVERRIDE_OVERRIDES_MEMBER_ID = "system_819b3743-0c3d-4896-b679-9aeeb73255f4";
+var WORLD_PLAY_DIRECTION_ENUM_ID = "system_705ccc39-e46e-4c9f-af3e-3ec8fd818709";
+var WORLD_PLAY_DIRECTION_FORWARD_OPTION_ID = "system_2e4ca40e-f305-49c6-a91b-b99d56239ba0";
+var WORLD_PLAY_DIRECTION_REVERSE_OPTION_ID = "system_6478d195-3905-48db-befe-d276eb5478f0";
+var WORLD_SYSTEM_CLASS_DEFINITIONS = [
+  {
+    classId: "system_fb9c4080-0148-530e-b9c0-8cd1c17ff8e7",
+    name: "NeoCellPattern",
+    docsText: "An immutable ordered pattern of cell offsets, relative to an origin.\nHand-built patterns preserve order and duplicates; factories order cells nearest first.",
+    modifier: 2 /* Sealed */,
+    constructorIds: ["system_f68684d6-6ea0-5d57-9f96-d544b17bf369"],
+    constructors: [
+      {
+        constructorId: "system_f68684d6-6ea0-5d57-9f96-d544b17bf369",
+        argumentTypes: [
+          {
+            name: "offsets",
+            type: 6,
+            required: true,
+            entryTypeInfo: { type: 15, required: true }
+          }
+        ],
+        code: "this._offsets = offsets.Select((offset) => { return Vector2Int(offset.x, offset.y); });"
+      }
+    ],
+    schemaFields: [
+      {
+        memberId: "system_02a01003-41ff-531c-a63c-1e905ca88d7d",
+        memberKind: "list",
+        access: 2 /* Private */,
+        modifier: 1 /* Sealed */,
         defaultValue: [],
         entryMemberId: "system_1efcbead-df5b-5d09-b0ca-758039c06fca",
         requirement: 1 /* Required */,
@@ -7805,6 +8419,43 @@ function clonePlain(value, path, visiting) {
   }
 }
 
+// ../packages/models/src/classes/world-system-classes.ts
+var WORLD_SYSTEM_CLASS_DEFINITION_BY_KIND = new Map(
+  WORLD_SYSTEM_CLASS_DEFINITIONS.map((definition) => [
+    definition.worldKind,
+    definition
+  ])
+);
+function worldSystemSchemaFieldsForKind(worldKind) {
+  return WORLD_SYSTEM_CLASS_DEFINITION_BY_KIND.get(worldKind)?.schemaFields ?? [];
+}
+var WORLD_SYSTEM_ANIMATION_KIND_MARKER = "animation";
+var WORLD_SYSTEM_ANIMATION_KINDS = new Set(
+  WORLD_SYSTEM_CLASS_DEFINITIONS.map(
+    (definition) => definition.worldKind
+  ).filter(
+    (worldKind) => worldKind.toLowerCase().includes(WORLD_SYSTEM_ANIMATION_KIND_MARKER)
+  )
+);
+var GENERIC_WORLD_SYSTEM_CLASS_KINDS = new Set(
+  WORLD_SYSTEM_CLASS_DEFINITIONS.filter(
+    (definition) => (definition.genericParams?.length ?? 0) > 0
+  ).map((definition) => definition.worldKind)
+);
+var WORLD_SYSTEM_ALL_KINDS = new Set(
+  WORLD_SYSTEM_CLASS_DEFINITIONS.map((definition) => definition.worldKind)
+);
+var WORLD_SYSTEM_SCHEMA_FIELD_SITES_BY_MEMBER_ID = new Map(
+  WORLD_SYSTEM_CLASS_DEFINITIONS.flatMap(
+    (definition) => (definition.schemaFields ?? []).map(
+      (field) => [
+        field.memberId,
+        { worldKind: definition.worldKind, schemaKey: field.schemaKey }
+      ]
+    )
+  )
+);
+
 // ../packages/models/src/classes/generics.ts
 var genericBindingsByClassIndex = /* @__PURE__ */ new WeakMap();
 function resolveGenericEnv(classId, classes, draft) {
@@ -8503,638 +9154,6 @@ function isAnimationChildOverrideEntrySlot(slotMember, members) {
   return false;
 }
 
-// ../packages/models/src/members/instance-provenance.ts
-var LITERAL_INSTANCE_IDENTITY_FIELDS = [
-  "classId",
-  "constructorArgs",
-  "instanceConstructorId",
-  "instanceVariantId",
-  "instanceVariantRowValueId",
-  "genericBindings"
-];
-function replaceLiteralValueClass(value, classId) {
-  const next = { ...value, classId };
-  for (const field of LITERAL_INSTANCE_IDENTITY_FIELDS) {
-    if (field !== "classId") Reflect.deleteProperty(next, field);
-  }
-  return next;
-}
-function overlayLiteralValueContent(base, override) {
-  const merged = { ...base, ...override };
-  if (!("value" in override) || override.value !== null) return merged;
-  for (const field of LITERAL_INSTANCE_IDENTITY_FIELDS) {
-    if (!Object.hasOwn(override, field)) Reflect.deleteProperty(merged, field);
-  }
-  return merged;
-}
-function pickInstanceProvenance(source) {
-  return {
-    ...source.constructorArgs === void 0 ? {} : { constructorArgs: source.constructorArgs },
-    ...source.instanceConstructorId === void 0 ? {} : { instanceConstructorId: source.instanceConstructorId },
-    ...source.instanceVariantId === void 0 ? {} : { instanceVariantId: source.instanceVariantId },
-    ...source.instanceVariantRowValueId === void 0 ? {} : { instanceVariantRowValueId: source.instanceVariantRowValueId }
-  };
-}
-function isVirtualInstanceRootShape(value) {
-  if (value.instanceConstructorId !== void 0) return true;
-  return typeof value.instanceVariantId === "string";
-}
-function isCollapseStampedInstanceRoot(value) {
-  return isLiteralValueContent(value) && isVirtualInstanceRootShape(value);
-}
-
-// ../packages/models/src/members/unordered-list-membership.ts
-function buildUnorderedListMembershipIndex(values) {
-  const membersByContainerId = /* @__PURE__ */ new Map();
-  for (const candidate of values) {
-    const containerId = candidate.containerId;
-    if (typeof containerId !== "string") continue;
-    const bucket = membersByContainerId.get(containerId);
-    if (bucket === void 0) {
-      membersByContainerId.set(containerId, [candidate.id]);
-    } else {
-      bucket.push(candidate.id);
-    }
-  }
-  for (const bucket of membersByContainerId.values()) {
-    bucket.sort();
-  }
-  return membersByContainerId;
-}
-
-// ../packages/models/src/members/member-value-id.ts
-var NEO_MEMBER_VALUE_NAMESPACE = "7f2b9c14-58d6-5a07-b3e1-4c9d0a6f8b25";
-var NEO_VIRTUAL_VALUE_NAMESPACE = "3e8ca0b3-e3f1-5d5f-bf2f-6ab5ee3896d0";
-var virtualNamespaceBytes = parse_default(NEO_VIRTUAL_VALUE_NAMESPACE);
-var virtualIdentityEncoder = new TextEncoder();
-var SURROGATE_CODE_UNIT = /[\ud800-\udfff]/;
-function derivedMemberValueId(memberId) {
-  return inSystemRecordNamespaceOf(
-    memberId,
-    v5_default(withoutSystemRecordIdPrefix(memberId), NEO_MEMBER_VALUE_NAMESPACE)
-  );
-}
-function virtualValueId(instanceRootId, sourceIdentity2) {
-  const identity = `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity2}`;
-  const bytes = SURROGATE_CODE_UNIT.test(identity) ? identity : virtualIdentityEncoder.encode(identity);
-  return inSystemRecordNamespaceOf(
-    instanceRootId,
-    v5_default(bytes, virtualNamespaceBytes)
-  );
-}
-function virtualSourceIdentityHead(sourceIdentity2) {
-  const pathStart = sourceIdentity2.indexOf(":$");
-  return pathStart < 0 ? sourceIdentity2 : sourceIdentity2.slice(0, pathStart);
-}
-function hasPendingVirtualSourceIdentity(sourceIdentity2) {
-  const head = virtualSourceIdentityHead(sourceIdentity2);
-  return head.startsWith("path:__pending__:") || head.startsWith("__pending__:");
-}
-var PENDING_VIRTUAL_VALUE_PREFIX = "__pending__:virtual-value:";
-function pendingVirtualValueId(pendingInstanceRootId, sourceIdentity2) {
-  return `${PENDING_VIRTUAL_VALUE_PREFIX}${encodeURIComponent(pendingInstanceRootId)}:${encodeURIComponent(sourceIdentity2)}`;
-}
-
-// ../packages/models/src/members/packed-value-encoding.ts
-var PACKED_VALUE_ENTRY_KEY = "~packed";
-var PackedValueEncodingError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PackedValueEncodingError";
-  }
-};
-var NO_CHILDREN = [];
-var NO_EDGES = /* @__PURE__ */ new Map();
-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(document2) {
-  const stored = document2.values;
-  const expanded = expandPackedValueRows(stored);
-  if (expanded === stored) return document2;
-  return { ...document2, 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 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 id = packedEntryLogicalId(entry, label, scope.constructionRootId);
-  if (scope.state.seenIds.has(id)) {
-    throw new PackedValueEncodingError(
-      `${label} resolves to id "${id}", which another row in the same packed payload already claims.`
-    );
-  }
-  scope.state.seenIds.add(id);
-  registerEdge(scope.state.edges, scope.ownerId, id);
-  const childScope = {
-    state: scope.state,
-    ownerId: id,
-    ownerLabel: `packed value "${id}"`,
-    constructionRootId: isCollapseStampedInstanceRoot(entry) ? id : scope.constructionRootId
-  };
-  const nested = [];
-  children.push(logicalChildRow(entry, id, childScope, nested));
-  children.push(...nested);
-  return id;
-}
-function logicalChildRow(entry, id, scope, children) {
-  const rowFields = {
-    id,
-    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;
-}
-var PACKED_ENTRY_FORBIDDEN_FIELDS = [
-  "projectId",
-  "containerId",
-  "mapKey"
-];
-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 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);
-}
-
-// ../packages/models/src/members/member-storage-key.ts
-var MAIN_STORAGE_PARTITION = "main";
-var STORAGE_KEY_INHERIT = "inherit";
-var STORAGE_KEY_ALL = "all";
-var PARENT_CLASS_TEMPLATE_TOKEN = "$parentClass";
-function normalizeStorageKeyDeclaration(declaration) {
-  if (declaration === void 0 || declaration === null) {
-    return STORAGE_KEY_INHERIT;
-  }
-  if (declaration.length === 0) return STORAGE_KEY_INHERIT;
-  if (declaration === STORAGE_KEY_ALL) {
-    throw new Error(
-      'Storage key "all" is reserved for partition-scoped reads and cannot be declared on a member.'
-    );
-  }
-  return declaration;
-}
-function storageKeyReferencesParentClass(declaration) {
-  return declaration.includes(PARENT_CLASS_TEMPLATE_TOKEN);
-}
-function resolveMapKeyForCreatedValue(args) {
-  const declaration = normalizeStorageKeyDeclaration(args.declaration);
-  if (declaration === STORAGE_KEY_INHERIT) return args.parentMapKey;
-  if (declaration === MAIN_STORAGE_PARTITION) return null;
-  if (storageKeyReferencesParentClass(declaration)) {
-    if (args.parentClassId === void 0) {
-      throw new Error(
-        `Storage key "${declaration}" references ${PARENT_CLASS_TEMPLATE_TOKEN}, but the placement parent value has no classId (only class-valued parents can anchor a ${PARENT_CLASS_TEMPLATE_TOKEN} partition).`
-      );
-    }
-    return declaration.replaceAll(
-      PARENT_CLASS_TEMPLATE_TOKEN,
-      args.parentClassId
-    );
-  }
-  return declaration;
-}
-
-// ../packages/models/src/members/storage-partitions.ts
-function stampCreatedValuesMapKey(values, mapKey) {
-  const normalized = mapKey === void 0 || mapKey === null || mapKey.length === 0 || mapKey === MAIN_STORAGE_PARTITION ? null : mapKey;
-  for (const value of values) {
-    if (normalized === null) {
-      delete value.mapKey;
-    } else {
-      value.mapKey = normalized;
-    }
-  }
-}
-function applyDeclaredStorageKeyOverrides(args) {
-  const boundaryValues = args.createdValues.filter(
-    (value) => normalizeStorageKeyDeclaration(
-      args.declarationByValueId.get(value.id)
-    ) !== STORAGE_KEY_INHERIT
-  );
-  if (boundaryValues.length === 0) return;
-  const createdById = new Map(
-    args.createdValues.map((value) => [value.id, value])
-  );
-  const parentOf = /* @__PURE__ */ new Map();
-  for (const value of args.createdValues) {
-    for (const childId of referencedValueIdCandidates(value.value)) {
-      if (createdById.has(childId)) parentOf.set(childId, value);
-    }
-  }
-  for (const value of args.createdValues) {
-    if (typeof value.containerId !== "string") continue;
-    const container = createdById.get(value.containerId);
-    if (container !== void 0) parentOf.set(value.id, container);
-  }
-  const depthOf = (value) => {
-    let depth = 0;
-    let current = value;
-    const seen = /* @__PURE__ */ new Set();
-    while (current !== void 0 && !seen.has(current.id)) {
-      seen.add(current.id);
-      current = parentOf.get(current.id);
-      if (current !== void 0) depth += 1;
-    }
-    return depth;
-  };
-  const boundaries = boundaryValues.sort((left, right) => depthOf(left) - depthOf(right));
-  for (const boundary of boundaries) {
-    const parentCreated = parentOf.get(boundary.id);
-    const parent = parentCreated !== void 0 ? {
-      mapKey: parentCreated.mapKey ?? null,
-      classId: parentCreated.classId ?? void 0
-    } : args.existingParentContextById?.get(boundary.id);
-    if (parent === void 0) {
-      throw new Error(
-        `Cannot resolve storage partition for created value "${boundary.id}": its placement parent is neither a created value nor supplied in existingParentContextById.`
-      );
-    }
-    const mapKey = resolveMapKeyForCreatedValue({
-      declaration: args.declarationByValueId.get(boundary.id),
-      parentMapKey: parent.mapKey,
-      parentClassId: parent.classId
-    });
-    for (const member of collectCreatedSubtreeValues(
-      boundary,
-      args.createdValues
-    )) {
-      if (mapKey === null || mapKey === MAIN_STORAGE_PARTITION) {
-        delete member.mapKey;
-      } else {
-        member.mapKey = mapKey;
-      }
-    }
-  }
-}
-function collectCreatedSubtreeValues(root, createdValues) {
-  const createdById = new Map(createdValues.map((value) => [value.id, value]));
-  const subtree = [];
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [root];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current === void 0) break;
-    if (visited.has(current.id)) continue;
-    visited.add(current.id);
-    subtree.push(current);
-    for (const childId of referencedValueIdCandidates(current.value)) {
-      const child = createdById.get(childId);
-      if (child !== void 0) queue.push(child);
-    }
-    for (const candidate of createdValues) {
-      if (candidate.containerId === current.id) queue.push(candidate);
-    }
-  }
-  return subtree;
-}
-function referencedValueIdCandidates(value) {
-  if (Array.isArray(value)) {
-    return value.filter((entry) => typeof entry === "string");
-  }
-  if (typeof value === "object" && value !== null) {
-    return Object.values(value).filter(
-      (entry) => typeof entry === "string"
-    );
-  }
-  return [];
-}
-
-// ../packages/models/src/core/auth-ownership-types.ts
-var ActorKind = {
-  /**
-   * `better-auth` user identities.
-   */
-  user: "user",
-  /**
-   * `better-auth` organization identities.
-   */
-  organization: "organization",
-  /**
-   * Used for denoting records created by a system.
-   */
-  system: "system"
-};
-function isActorIdentifier(value) {
-  if (typeof value !== "object") return false;
-  if (value === null) return false;
-  const candidate = value;
-  if (!isActorKind(candidate.kind)) return false;
-  return typeof candidate.id === "string" && candidate.id.trim().length > 0;
-}
-function isActorKind(value) {
-  return value === ActorKind.user || value === ActorKind.organization || value === ActorKind.system;
-}
-
-// ../packages/models/src/members/member-change-listeners.ts
-function editChangeListenerSet(explicit, inherited, edit, options = { inheritedComplete: true }) {
-  if (edit.kind === "reset") {
-    return explicit === void 0 ? { changed: false } : { changed: true, targets: void 0 };
-  }
-  const current = explicit ?? inherited;
-  let next;
-  if (edit.kind === "replace") {
-    next = edit.targets;
-  } else {
-    const identity = nsActionListenerIdentity(edit.target);
-    const index = current.findIndex(
-      (target) => nsActionListenerIdentity(target) === identity
-    );
-    if (edit.kind === "add") {
-      if (index !== -1) return { changed: false };
-      next = [...current, edit.target];
-    } else {
-      if (index === -1) return { changed: false };
-      next = current.filter((_, i) => i !== index);
-    }
-  }
-  const targets = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const target of next) {
-    const identity = nsActionListenerIdentity(target);
-    if (seen.has(identity))
-      throw new Error("A listener set cannot repeat a handler identity.");
-    seen.add(identity);
-    targets.push({ memberId: target.memberId, valueId: target.valueId });
-  }
-  if (targets.length === 0 && inherited.length === 0 && options.inheritedComplete) {
-    return explicit === void 0 ? { changed: false } : { changed: true, targets: void 0 };
-  }
-  if (explicit !== void 0 && sameChangeListeners(explicit, targets))
-    return { changed: false };
-  return { changed: true, targets };
-}
-function sameChangeListeners(left, right) {
-  return left.length === right.length && left.every(
-    (entry, index) => entry.memberId === right[index].memberId && entry.valueId === right[index].valueId
-  );
-}
-function remapChangeListenerMap(map, identities, policy, internalEndpoints) {
-  if (!map) return void 0;
-  const result = {};
-  for (const [ownerId, members] of Object.entries(map)) {
-    const owner = identities.get(ownerId);
-    if (owner === void 0) continue;
-    const entry = {};
-    for (const [memberId, targets] of Object.entries(members)) {
-      const remapped = [];
-      for (const target of targets) {
-        const receiver = target.valueId === null ? null : identities.get(target.valueId);
-        if (receiver === void 0 && (policy === "clone" || target.valueId !== null && internalEndpoints !== void 0 && internalEndpoints.has(target.valueId)))
-          continue;
-        remapped.push({
-          memberId: target.memberId,
-          valueId: receiver ?? target.valueId
-        });
-      }
-      setOwnField(entry, memberId, remapped);
-    }
-    setOwnField(result, owner, entry);
-  }
-  return Object.keys(result).length === 0 ? void 0 : result;
-}
-var authoredListenerIndexes = /* @__PURE__ */ new WeakMap();
-function authoredChangeListenerOwners(rows) {
-  const index = authoredListenerIndexes.get(rows);
-  if (index !== void 0) return index;
-  const owners = /* @__PURE__ */ new Map();
-  for (const row of rows)
-    for (const [ownerId, entry] of Object.entries(row.changeListeners ?? {})) {
-      if (owners.has(ownerId))
-        throw new Error(
-          `Listener owner "${ownerId}" is declared on more than one binding root.`
-        );
-      owners.set(ownerId, entry);
-    }
-  authoredListenerIndexes.set(rows, owners);
-  return owners;
-}
-var declarationListenerMetadata = /* @__PURE__ */ new WeakMap();
-function hasAuthoredChangeListenerMetadata(document2) {
-  if (authoredChangeListenerOwners(document2.values).size !== 0) return true;
-  let present = declarationListenerMetadata.get(document2.members);
-  if (present === void 0) {
-    present = document2.members.some(
-      (member) => member.defaultValue?.changeListeners !== void 0
-    );
-    declarationListenerMetadata.set(document2.members, present);
-  }
-  return present;
-}
-function defaultSourceWithListeners(row, graph) {
-  if (row === null || graph == null || graph.instanceRootId !== row.id)
-    return row;
-  const inherited = graph.listenerDefaultsByOwner;
-  if (inherited === void 0 || inherited.size === 0) return row;
-  const map = Object.fromEntries(inherited);
-  for (const [id, entry] of Object.entries(row.changeListeners ?? {}))
-    setOwnField(map, id, { ...map[id], ...entry });
-  return { ...row, changeListeners: map };
-}
-
 // ../packages/models/src/constructors/constructors.ts
 var REJECTED_CONSTRUCTOR_KEYS = [
   "bodyMode",
@@ -9320,7 +9339,7 @@ function constructionMembers(classId, context) {
   const { document: document2, memberById, env } = context;
   if (firstUnboundParamId(env) !== null) return [];
   const result = [];
-  for (const entry of mergeStoredInstanceSchema(
+  for (const entry of mergeInstanceSurfaceSchema(
     classId,
     document2.classes,
     document2.members
@@ -9338,7 +9357,6 @@ function constructionMembers(classId, context) {
       id: raw.id
     };
     if (isAbstractMember(member)) continue;
-    if (isReadOnlyMember(member)) continue;
     if (!memberKindOwnsStoredValue(member.kind)) continue;
     if ("payload" in member && member.payload === 1 /* Partial */)
       continue;
@@ -10569,7 +10587,7 @@ function withIndexedDefaultValueDocument(document2, options = {}) {
         classId,
         document2.classes,
         document2.members
-      ).stored;
+      ).surface;
       cache.storedSchemaByClassId.set(classId, schema);
       return schema;
     },
@@ -10649,26 +10667,219 @@ function buildDefaultClassMaterializationPlan(document2, classId, instanceEnv) {
     ...document2,
     constructors: document2.constructors ?? []
   });
-  const merged = document2.storedInstanceSchema?.(classId) ?? mergeStoredInstanceSchema(classId, document2.classes, document2.members);
-  return merged.flatMap((entry) => {
-    if (entry.memberId === null) return [];
-    const childMember = findMemberInDocument(document2, entry.memberId);
-    if (!memberKindOwnsStoredValue(childMember.kind)) return [];
-    const member = substituteMember(
-      childMember,
-      instanceEnv,
-      document2.members,
-      document2.resolvedMember?.(childMember)
-    );
-    return [
-      {
-        schemaKey: entry.schemaKey,
-        member,
-        defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
-        directScalarBody: directScalarDefaultBody(document2, member)
+  return storedSchemaOf(document2, classId).flatMap(
+    (entry) => {
+      if (entry.memberId === null) return [];
+      const childMember = findMemberInDocument(document2, entry.memberId);
+      if (!memberKindOwnsStoredValue(childMember.kind)) return [];
+      if (instanceEnv.size === 0 && isConstantMember(document2, resolvedInDocument(document2, childMember)))
+        return [];
+      const member = substituteMember(
+        childMember,
+        instanceEnv,
+        document2.members,
+        document2.resolvedMember?.(childMember)
+      );
+      return [
+        {
+          schemaKey: entry.schemaKey,
+          member,
+          defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
+          directScalarBody: directScalarDefaultBody(document2, member)
+        }
+      ];
+    }
+  );
+}
+function isConstantMember(document2, resolved) {
+  if (isStaticMember(resolved)) return false;
+  const fixedness = fixednessOf(resolved, 0 /* Writable */);
+  if (fixedness === 0 /* Writable */) return false;
+  const declared = resolved.defaultValue;
+  if (declared == null) return false;
+  if (fixedness === 1 /* ReadOnly */ && (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)))
+    return false;
+  return !declarationVaries(
+    {
+      document: document2,
+      rows: /* @__PURE__ */ new Set(),
+      declarations: /* @__PURE__ */ new Set(),
+      classes: /* @__PURE__ */ new Set()
+    },
+    resolved,
+    declared,
+    null,
+    { fixedness, ownsReads: true }
+  );
+}
+function fixednessOf(resolved, parent) {
+  const storage = resolved.storage ?? 0 /* Inherit */;
+  if (storage === 1 /* Immutable */) return 2 /* Immutable */;
+  if (storage === 0 /* Inherit */ && parent === 2 /* Immutable */)
+    return 2 /* Immutable */;
+  return isReadOnlyMember(resolved) ? 1 /* ReadOnly */ : 0 /* Writable */;
+}
+function scopeKey(id, scope) {
+  return `${id}:${scope.fixedness}:${scope.ownsReads}`;
+}
+function resolvedInDocument(document2, member) {
+  return document2.resolvedMember?.(member) ?? resolveMember(member, document2.members);
+}
+function declarationVaries(walk, member, body, rowId, scope) {
+  const { document: document2 } = walk;
+  const { ownsReads } = scope;
+  const immutable2 = scope.fixedness === 2 /* Immutable */;
+  if (documentHasInitValueContent(document2, body)) {
+    if (!immutable2) return true;
+    if (ownsReads) {
+      const compiled = body.init.compiled;
+      if (compiled === void 0) return true;
+      if (initializerReadsInstance(compiled)) return true;
+    }
+    return typeHoldsWritable(walk, member, 2 /* Immutable */);
+  }
+  if (!isLiteralValueContent(body)) return true;
+  if (!immutable2 && body.instanceConstructorId !== void 0) return true;
+  if (!immutable2 && body.constructorArgs != null) return true;
+  if (ownsReads && irReadsInstance(body.constructorArgs, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()))
+    return true;
+  const value = body.value;
+  if (isMemberClassBase(member)) {
+    if (value === null) return false;
+    if (!isStringRecord(value)) return true;
+    const classId = typeof body.classId === "string" ? body.classId : member.classId;
+    let owned = 0;
+    for (const entry of storedSchemaOf(document2, classId)) {
+      if (entry.memberId === null) continue;
+      const child = resolvedInDocument(
+        document2,
+        findMemberInDocument(document2, entry.memberId)
+      );
+      const childId = value[entry.schemaKey];
+      if (childId !== void 0) owned++;
+      else if (!memberKindOwnsStoredValue(child.kind) || isStaticMember(child))
+        continue;
+      const fixedness = fixednessOf(child, scope.fixedness);
+      if (fixedness === 0 /* Writable */) return true;
+      if (childId !== void 0) {
+        if (rowVaries(walk, child, childId, { fixedness, ownsReads }))
+          return true;
+        continue;
       }
-    ];
-  });
+      const declared = child.defaultValue;
+      if (declared == null) continue;
+      const childScope = { fixedness, ownsReads: false };
+      const key = scopeKey(entry.memberId, childScope);
+      if (walk.declarations.has(key)) continue;
+      walk.declarations.add(key);
+      if (declarationVaries(walk, child, declared, null, childScope))
+        return true;
+    }
+    return owned !== Object.keys(value).length;
+  }
+  if (isMemberListBase(member)) {
+    const entryIds = listKindOf(member) !== 1 /* Unordered */ ? value : rowId === null ? [] : document2.unorderedListEntryIds?.(rowId) ?? (walk.membership ??= buildUnorderedListMembershipIndex(
+      document2.values
+    )).get(rowId) ?? [];
+    if (entryIds === null) return false;
+    if (!Array.isArray(entryIds)) return true;
+    return entriesVary(walk, member.entryMemberId, entryIds, scope);
+  }
+  if (isMemberDictionaryBase(member)) {
+    if (value === null) return false;
+    if (!isStringRecord(value)) return true;
+    return entriesVary(walk, member.entryMemberId, Object.values(value), scope);
+  }
+  if (member.kind === 21 /* Generic */) return true;
+  return ownsReads && irReadsInstance(value, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+}
+function entriesVary(walk, entryMemberId, entryIds, scope) {
+  if (entryIds.length === 0) return false;
+  const entryMember = resolvedInDocument(
+    walk.document,
+    findMemberInDocument(walk.document, entryMemberId)
+  );
+  const fixedness = fixednessOf(entryMember, scope.fixedness);
+  if (fixedness === 0 /* Writable */) return true;
+  const entryScope = { fixedness, ownsReads: scope.ownsReads };
+  return entryIds.some(
+    (entryId) => typeof entryId !== "string" || rowVaries(walk, entryMember, entryId, entryScope)
+  );
+}
+function rowVaries(walk, member, valueId, scope) {
+  const key = scopeKey(valueId, scope);
+  if (walk.rows.has(key)) return false;
+  walk.rows.add(key);
+  const { document: document2 } = walk;
+  const row = document2.valueById?.(valueId) ?? (walk.rowById ??= new Map(
+    document2.values.map((value) => [value.id, value])
+  )).get(valueId);
+  if (row === void 0 || row === null) return true;
+  return declarationVaries(walk, member, row, row.id, scope);
+}
+function typeHoldsWritable(walk, member, fixedness) {
+  if (isMemberClassBase(member)) {
+    const { classes } = walk.document;
+    if (!classIndexFor(classes).has(member.classId)) return true;
+    if (classHoldsWritable(walk, member.classId, fixedness)) return true;
+    for (const classId of descendantClassIds(member.classId, classes)) {
+      if (classHoldsWritable(walk, classId, fixedness)) return true;
+    }
+    return false;
+  }
+  if (isMemberListBase(member) || isMemberDictionaryBase(member)) {
+    const entryMember = resolvedInDocument(
+      walk.document,
+      findMemberInDocument(walk.document, member.entryMemberId)
+    );
+    const entryFixedness = fixednessOf(entryMember, fixedness);
+    return entryFixedness === 0 /* Writable */ || typeHoldsWritable(walk, entryMember, entryFixedness);
+  }
+  return member.kind === 21 /* Generic */;
+}
+function classHoldsWritable(walk, classId, fixedness) {
+  const key = `${classId}:${fixedness}`;
+  if (walk.classes.has(key)) return false;
+  walk.classes.add(key);
+  const { document: document2 } = walk;
+  for (const entry of storedSchemaOf(document2, classId)) {
+    if (entry.memberId === null) continue;
+    const child = resolvedInDocument(
+      document2,
+      findMemberInDocument(document2, entry.memberId)
+    );
+    if (!memberKindOwnsStoredValue(child.kind) || isStaticMember(child))
+      continue;
+    const childFixedness = fixednessOf(child, fixedness);
+    if (childFixedness === 0 /* Writable */) return true;
+    if (typeHoldsWritable(walk, child, childFixedness)) return true;
+  }
+  return false;
+}
+function storedSchemaOf(document2, classId) {
+  return document2.storedInstanceSchema?.(classId) ?? resolvedClassSchema(classId, document2.classes, document2.members).surface;
+}
+function initializerReadsInstance(compiled) {
+  const instanceParameters = /* @__PURE__ */ new Set();
+  for (const parameter3 of compiled.parameters) {
+    if (parameter3.id !== "__root__") instanceParameters.add(parameter3.id);
+  }
+  return irReadsInstance(compiled.instructions, instanceParameters, /* @__PURE__ */ new Set());
+}
+function irReadsInstance(value, instanceParameters, visited) {
+  if (typeof value !== "object" || value === null) return false;
+  if (visited.has(value)) return false;
+  visited.add(value);
+  if (isMemberDelegateTarget(value) && value.valueId === null) return true;
+  if (Reflect.get(value, "type") === "variable" /* variable */) {
+    const variableId = Reflect.get(value, "variableId");
+    if (typeof variableId === "string" && instanceParameters.has(variableId))
+      return true;
+  }
+  for (const child of Object.values(value)) {
+    if (irReadsInstance(child, instanceParameters, visited)) return true;
+  }
+  return false;
 }
 function assertLookupInitializerLiteral(member, literal3) {
   if (!isMemberLookupBase(member)) return;
@@ -11515,7 +11726,7 @@ function formatDefaultReferenceLocation(memberName, key) {
 function getSchemaEntryMap(document2, classId) {
   const node = resolvedClassSchema(classId, document2.classes, document2.members);
   const entries = document2.storedInstanceSchema?.(classId);
-  return entries === void 0 || entries === node.stored ? node.storedByKey : new Map(entries.map((entry) => [entry.schemaKey, entry]));
+  return entries === void 0 || entries === node.surface ? node.surfaceByKey : new Map(entries.map((entry) => [entry.schemaKey, entry]));
 }
 function cloneMemberValueBase(body) {
   return {
@@ -12662,6 +12873,50 @@ function buildNeoScriptConstructorSignature(classId, members, memberDescriptor)
     parameters
   };
 }
+function buildNeoScriptConstructionSignatures(classId, members, memberDescriptor, immutableOnly) {
+  const descriptors = /* @__PURE__ */ new Map();
+  const describe = (memberId) => {
+    let descriptor = descriptors.get(memberId);
+    if (descriptor === void 0) {
+      descriptor = memberDescriptor(memberId);
+      descriptors.set(memberId, descriptor);
+    }
+    return descriptor;
+  };
+  const replay = buildNeoScriptConstructorSignature(classId, members, describe);
+  if (immutableOnly) {
+    return {
+      storedConstructionReplaySignature: replay,
+      constructorUnavailableReason: "immutableOnly"
+    };
+  }
+  let hasImmutableMember = false;
+  for (const descriptor of descriptors.values()) {
+    if (descriptor?.immutable !== true) continue;
+    if (constructorParameterIsRequired(
+      descriptor.required,
+      descriptor.defaultValue
+    )) {
+      return {
+        storedConstructionReplaySignature: replay,
+        constructorUnavailableReason: "requiredImmutableMember"
+      };
+    }
+    hasImmutableMember = true;
+  }
+  if (!hasImmutableMember) return { constructorSignature: replay };
+  return {
+    constructorSignature: buildNeoScriptConstructorSignature(
+      classId,
+      members,
+      (memberId) => {
+        const descriptor = describe(memberId);
+        return descriptor?.immutable === true ? null : descriptor;
+      }
+    ),
+    storedConstructionReplaySignature: replay
+  };
+}
 function isNeoScriptTypeAssignable(source, target, project) {
   if (isUnknownType(source) || isUnknownType(target)) return false;
   if (isNullType(source)) return isNullableType2(target);
@@ -13340,7 +13595,7 @@ function resolveOwnerMembersForValues(document2, targetValueIds, additionalRoots
   function storedSchema(classId) {
     const cached = storedSchemaByClassId.get(classId);
     if (cached !== void 0) return cached;
-    const created = mergeStoredInstanceSchema(
+    const created = mergeInstanceSurfaceSchema(
       classId,
       document2.classes,
       document2.members
@@ -15308,15 +15563,15 @@ function classImplementsInterface(classId, interfaceId, classes, interfaces) {
 function readClassMember(args) {
   const { member, schemaKey } = args;
   const declaration = member.kind !== 10 /* NSProperty */ && member.defaultValue != null ? member.defaultValue : void 0;
-  if (args.mode !== "partial" && isReadOnlyMember(member) && declaration !== void 0)
-    return { kind: "declaration", content: declaration };
   if (Object.prototype.hasOwnProperty.call(args.record, schemaKey))
     return { kind: "value", value: Reflect.get(args.record, schemaKey) };
   if (args.mode === "partial") return { kind: "missing" };
   const expanded = args.expandedRecord();
   if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, schemaKey))
     return { kind: "value", value: Reflect.get(expanded, schemaKey) };
-  if (args.mode !== "resolved" && declaration !== void 0)
+  if (args.mode === "resolved")
+    return declaration !== void 0 && args.isConstant() ? { kind: "declaration", content: declaration } : { kind: "missing" };
+  if (declaration !== void 0)
     return { kind: "declaration", content: declaration };
   if (args.mode === "runtime" && !isRequiredMember(member))
     return { kind: "null" };
@@ -16822,6 +17077,7 @@ function withEvaluationRuntime(ctx, writes) {
       constructionTimestamp: Date.now(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
       constructionStack: [],
+      openConstructions: /* @__PURE__ */ new Map(),
       loopIterations: 0,
       budgetedConstructedRowIds: /* @__PURE__ */ new Set(),
       budgetedProducedEntriesByRowId: /* @__PURE__ */ new Map(),
@@ -17957,14 +18213,16 @@ function evalInstructions(instructions, scope, ctx, options) {
             };
           }
           const assignedReferenceValueId = targetTypeInfo.type === 7 /* Class */ || targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 5 /* Dictionary */ ? findKnownRowIdByValueReference(value, ctx) : null;
-          applyOverlayAssignment(
-            ins.target.pointer,
-            targetTypeInfo,
-            value,
-            scope,
-            ctx,
-            destination
-          );
+          if (!bindOmittedConstantSlot(destination, member, value, ctx)) {
+            applyOverlayAssignment(
+              ins.target.pointer,
+              targetTypeInfo,
+              value,
+              scope,
+              ctx,
+              destination
+            );
+          }
           const unorderedReplacement = assignedReferenceValueId === null && member !== null && isMemberListBase(member) && listKindOf(member) === 1 /* Unordered */ && Array.isArray(value) ? unorderedReplacementProjection(
             ins.target.pointer,
             destination,
@@ -18580,7 +18838,6 @@ function evalActionListenerInstruction(ins, scope, ctx, options) {
     scope,
     ctx,
     target.optional === true,
-    target.memberId,
     (resolved) => {
       destination = resolved;
     }
@@ -18820,6 +19077,36 @@ function applyOverlayStaticAssignment(memberId, value, ctx) {
   bindings.set(member.id, row.id);
   invalidateEvaluatorIndexes(ctx);
 }
+function bindOmittedConstantSlot(destination, member, value, ctx) {
+  if (destination === void 0 || member === null) return false;
+  const { receiver } = destination;
+  if (typeof receiver !== "object" || receiver === null) return false;
+  const construction = ctx.__executionState?.openConstructions.get(receiver);
+  if (construction === void 0) return false;
+  const key = String(destination.key);
+  if (Object.prototype.hasOwnProperty.call(receiver, key)) return false;
+  if (isMemberClassBase(member) || isMemberListBase(member) || isMemberDictionaryBase(member))
+    return false;
+  const resolved = resolveMember(member, ctx.vm.members);
+  if (!isConstantMember(constructorDefaultValueDocument(ctx, member), resolved))
+    return false;
+  const { createdValues } = construction;
+  const staged = createdValues.length;
+  const row = materializeConstructorArgumentValue({
+    member: resolved,
+    value,
+    // A constant has no instance environment.
+    genericEnv: /* @__PURE__ */ new Map(),
+    ctx,
+    createdValues,
+    createdById: /* @__PURE__ */ new Map(),
+    storageKeyDeclarations: construction.storageKeyDeclarations
+  });
+  stageConstructedRows(createdValues.slice(staged), ctx);
+  Reflect.set(receiver, key, row.id);
+  invalidateEvaluatorIndexes(ctx, receiver);
+  return true;
+}
 function touchUnknown(_ins) {
   void _ins;
 }
@@ -19580,13 +19867,7 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "staticMember" /* staticMember */:
       return evalStaticMember(pointer.memberId, ctx);
     case "keyOf" /* keyOf */:
-      return evalKeyOf(
-        pointer.keyOf,
-        scope,
-        ctx,
-        pointer.optional === true,
-        pointer.memberId
-      );
+      return evalKeyOf(pointer.keyOf, scope, ctx, pointer.optional === true);
     case "operation" /* operation */:
       return evalOperation(pointer.operation, scope, ctx);
     case "function" /* function */:
@@ -20217,7 +20498,6 @@ function readActionWithOwner(pointer, scope, ctx) {
     scope,
     ctx,
     pointer.optional === true,
-    pointer.memberId,
     (destination) => {
       owner = destination.receiver;
     }
@@ -21030,7 +21310,7 @@ function isRuntimeSpriteValue(value) {
   const sliceIndex = value.sliceIndex;
   return typeof sliceIndex === "number" && Number.isInteger(sliceIndex) && sliceIndex >= 0;
 }
-function evalKeyOf(keyOf, scope, ctx, optional2 = false, memberId, onDestination) {
+function evalKeyOf(keyOf, scope, ctx, optional2 = false, onDestination) {
   const receiver = evalPointer(keyOf.pointer, scope, ctx);
   if (optional2 && (receiver === null || receiver === void 0)) {
     return null;
@@ -21089,11 +21369,6 @@ function evalKeyOf(keyOf, scope, ctx, optional2 = false, memberId, onDestination
     if (assetMember.kind === "ok") return assetMember.value;
     const dispatched = dispatchSchemaMember(receiver, k, ctx);
     if (dispatched.kind === "ok") return dispatched.value;
-    if (!dispatched.matchedMember && memberId !== void 0) {
-      const member = evalMemberById(ctx.vm, memberId);
-      const defaultValue = isReadOnlyMember(member) ? readDeclarationDefault(member, ctx) : { matched: false };
-      if (defaultValue.matched) return defaultValue.value;
-    }
     if (Object.prototype.hasOwnProperty.call(receiver, k)) {
       const at2 = receiver[k];
       return resolveValueIfId(at2, ctx);
@@ -21196,16 +21471,36 @@ function ensureVirtualExpansionIndexed(rows, ctx, existingIndexes) {
   );
   indexes3.indexedVirtualRowSets.add(rows);
 }
+var constantDeclarationRoots = /* @__PURE__ */ new WeakMap();
 function readDeclarationDefault(member, ctx) {
   if (member?.defaultValue === void 0 || member.defaultValue === null) {
     return { matched: false };
   }
   if (isInitValueContent(member.defaultValue) || isMemberClassBase(member) || isMemberListBase(member) || isMemberDictionaryBase(member)) {
+    const session = ctx.__runtimeSessionValues;
+    let shared;
+    if (session !== void 0) {
+      shared = constantDeclarationRoots.get(session);
+      if (shared === void 0) {
+        shared = /* @__PURE__ */ new Map();
+        constantDeclarationRoots.set(session, shared);
+      }
+    }
+    const known = shared?.get(member.id);
+    if (typeof known === "string" && session?.has(known) === true) {
+      return {
+        matched: true,
+        value: resolveValueIfIdForMember(known, member, ctx)
+      };
+    }
+    const document2 = constructorDefaultValueDocument(ctx, member);
+    const constant = shared !== void 0 && known !== false && (known !== void 0 || isConstantMember(document2, member));
+    if (shared !== void 0 && !constant) shared.set(member.id, false);
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
     try {
       const root = buildDefaultMemberValue({
-        document: constructorDefaultValueDocument(ctx, member),
+        document: document2,
         projectId: ctx.vm.project.id,
         member,
         createdValues: created,
@@ -21226,6 +21521,7 @@ function readDeclarationDefault(member, ctx) {
         )
       });
       stageConstructedRows([root, ...created], ctx);
+      if (constant) shared?.set(member.id, root.id);
       return {
         matched: true,
         value: resolveValueIfIdForMember(root.id, member, ctx)
@@ -23342,12 +23638,6 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
     }
     seenSchemaKeys.add(field.schemaKey);
     seenMemberIds.add(field.memberId);
-    assertConstructorFieldSlotWritable({
-      schemaKey: field.schemaKey,
-      settledClassId: classId,
-      schemaClassName: schemaClass2.name,
-      ctx
-    });
     const schemaEntry = schemaByKey.get(field.schemaKey);
     if (schemaEntry === void 0) {
       throw new NSGetterRuntimeError(
@@ -23402,21 +23692,6 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   }
   return cacheDescriptor({ schemaClass: schemaClass2, fields, instanceEnv, classArguments: classArguments2 });
 }
-function assertConstructorFieldSlotWritable(args) {
-  const index = evaluatorSchemaIndex(args.ctx);
-  const surfaceEntry = resolvedClassSchemaFromIndexes(
-    args.settledClassId,
-    index.classesById,
-    index.membersById
-  ).surfaceByKey.get(args.schemaKey);
-  if (surfaceEntry === void 0) return;
-  if (isReadOnlyMember(evalMemberById(args.ctx.vm, surfaceEntry.memberId)) !== true) {
-    return;
-  }
-  throw new NSGetterRuntimeError(
-    `Constructor field '${args.schemaKey}' on '${args.schemaClassName}' is a read-only declaration member and cannot have an instance value.`
-  );
-}
 function validateConstructorFieldSlot(args) {
   const { schemaKey, ctx } = args;
   const rawMember = evalMemberById(ctx.vm, args.memberId);
@@ -23436,6 +23711,11 @@ function validateConstructorFieldSlot(args) {
       `Constructor field '${schemaKey}' on '${args.schemaClassName}' is not a stored concrete member.`
     );
   }
+  if (member.storage === 1 /* Immutable */ && ctx.storedConstructionReplay !== true) {
+    throw new NSGetterRuntimeError(
+      `Constructor field '${schemaKey}' on '${args.schemaClassName}' is Immutable; runtime construction cannot set it.`
+    );
+  }
   const typeInfo = runtimeTypeInfoForMember(
     rawMember,
     args.instanceEnv,
@@ -24315,7 +24595,7 @@ function evaluateBaseInitializerFields(args) {
     )
   );
   const instanceSchema = new Map(
-    mergeStoredInstanceSchema(
+    mergeInstanceSurfaceSchema(
       args.constructedClassId,
       ctx.vm.classes,
       ctx.vm.members
@@ -24339,12 +24619,6 @@ function evaluateBaseInitializerFields(args) {
         `Constructor '${record4.id}' settles base member '${field.name}', which the constructed instance does not store.`
       );
     }
-    assertConstructorFieldSlotWritable({
-      schemaKey: field.name,
-      settledClassId: args.constructedClassId,
-      schemaClassName: owningClass.name,
-      ctx
-    });
     const validated = validateConstructorFieldSlot({
       schemaKey: field.name,
       memberId: entry.memberId,
@@ -25727,39 +26001,50 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
   stageConstructedRows(createdValues, ctx);
   bindConstructedDelegateTargets(createdValues, ctx);
   if (record4 !== null) {
-    runDeclaredConstructorChain({
-      record: record4,
-      argumentValues,
-      preparedArgumentScopes,
-      thisValue: root.value,
-      ctx,
-      visitedConstructorIds: /* @__PURE__ */ new Set(),
-      applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
-        const supplied2 = evaluateBaseInitializerFields({
-          record: chainRecord,
-          argumentValues: chainArguments,
-          thisValue: chainThisValue,
-          constructedClassId: classId,
-          instanceEnv: descriptor.instanceEnv,
-          ctx
-        });
-        if (supplied2.length === 0) return;
-        applyConstructorFields({
-          supplied: supplied2,
-          root,
-          rootRecord,
-          schemaClass: schemaClass2,
-          instanceEnv: descriptor.instanceEnv,
-          createdValues,
-          createdById: new Map(createdValues.map((row) => [row.id, row])),
-          storageKeyDeclarations,
-          // §1.5 base blocks are assignments, not omissions: an explicit null
-          // clears the slot exactly as a call-site block entry does.
-          nullMeansOmit: false,
-          ctx
-        });
-      }
+    const openConstructions = ctx.__executionState?.openConstructions;
+    openConstructions?.set(rootRecord, {
+      createdValues,
+      storageKeyDeclarations
     });
+    try {
+      runDeclaredConstructorChain({
+        record: record4,
+        argumentValues,
+        preparedArgumentScopes,
+        thisValue: root.value,
+        ctx,
+        visitedConstructorIds: /* @__PURE__ */ new Set(),
+        applyBaseInitializerBlock: (chainRecord, chainArguments, chainThisValue) => {
+          const supplied2 = evaluateBaseInitializerFields({
+            record: chainRecord,
+            argumentValues: chainArguments,
+            thisValue: chainThisValue,
+            constructedClassId: classId,
+            instanceEnv: descriptor.instanceEnv,
+            ctx
+          });
+          if (supplied2.length === 0) return;
+          const staged = createdValues.length;
+          applyConstructorFields({
+            supplied: supplied2,
+            root,
+            rootRecord,
+            schemaClass: schemaClass2,
+            instanceEnv: descriptor.instanceEnv,
+            createdValues,
+            createdById: new Map(createdValues.map((row) => [row.id, row])),
+            storageKeyDeclarations,
+            // §1.5 base blocks are assignments, not omissions: an explicit null
+            // clears the slot exactly as a call-site block entry does.
+            nullMeansOmit: false,
+            ctx
+          });
+          stageConstructedRows(createdValues.slice(staged), ctx);
+        }
+      });
+    } finally {
+      openConstructions?.delete(rootRecord);
+    }
   }
   const supplied = evaluateConstructorFields(descriptor, scope, ctx);
   try {
@@ -27212,7 +27497,7 @@ function createStoredValuePlacementTraversal(args, trackReferences = false) {
   const storedSchema = (classId) => {
     const cached = storedSchemaByClassId.get(classId);
     if (cached !== void 0) return cached;
-    const schema = mergeStoredInstanceSchema(
+    const schema = mergeInstanceSurfaceSchema(
       classId,
       args.classes,
       args.members
@@ -27909,7 +28194,7 @@ function collectSoftOwnedConstructorArgumentValueIds(index, ownerValueId, preser
     const effectiveClassId = row.classId ?? (typeInfo.type === 7 /* Class */ ? typeInfo.classId : void 0);
     if (effectiveClassId === void 0) return;
     const env = rowGenericEnvironment(index.document, row);
-    const merged = mergeStoredInstanceSchema(
+    const merged = mergeInstanceSurfaceSchema(
       effectiveClassId,
       index.document.classes,
       index.document.members
@@ -30771,7 +31056,7 @@ function resolveVirtualInstanceGraph(args) {
         classId,
         args.document.classes,
         args.document.members
-      ).stored;
+      ).surface;
       for (const entry of schema) {
         const childPath = appendVirtualValuePath(pathKey, {
           kind: "class",
@@ -31522,7 +31807,7 @@ function indexExpansion(args) {
         classId,
         args.document.classes,
         args.document.members
-      ).stored;
+      ).surface;
       for (const entry of schema) {
         const childId = record4[entry.schemaKey];
         const childMember = membersById.get(entry.memberId);
@@ -34344,6 +34629,12 @@ var WRITE_TARGET_DESCRIPTIONS = {
   unknown: "something other than `this` or a local"
 };
 var ON_CHANGED_OPERATIONS_ERROR = "OnChanged supports only '+=', '-=', and Clear().";
+function immutableRuntimeConstructionError(name) {
+  return `Runtime construction cannot set Immutable member '${name}'; it reads its declared initializer.`;
+}
+function readonlyWriteError(name) {
+  return `Member '${name}' is readonly; set it in its initializer, a constructor, or an object initializer.`;
+}
 var FALLTHROUGH_LABELS = {
   function: "NSFunction",
   getter: "getter",
@@ -36087,7 +36378,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope
     );
     const target = statement.op === "=" ? { ...resolvedTarget, type: storageType } : resolvedTarget;
-    const writability = local?.writability ?? target.writability;
+    const initSlot = target.initWritability !== void 0 ? {
+      pointer: target.pointer,
+      initWritability: target.initWritability
+    } : target.readonlyCollection;
+    const initializing = initSlot !== void 0 && this.constructsSlot(initSlot.pointer, assignmentContext);
+    const writability = initializing ? initSlot.initWritability : local?.writability ?? target.writability;
     if (target.symbol?.computed === true && target.symbol.writable !== true) {
       throw new CompileError(
         `Cannot assign to NeoScript property '${target.symbol.name}' because it does not declare a setter.`,
@@ -36100,9 +36396,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    if (target.symbol?.readonlyDeclaration === true) {
+    if (target.symbol?.readonlyDeclaration === true && !initializing) {
       throw new CompileError(
-        `Member '${target.symbol.name}' is readonly and can only be changed through its class default.`,
+        readonlyWriteError(target.symbol.name),
+        statement.pos
+      );
+    }
+    if (target.readonlyCollection !== void 0 && !initializing) {
+      throw new CompileError(
+        readonlyWriteError(target.readonlyCollection.name),
         statement.pos
       );
     }
@@ -36121,7 +36423,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    if (writability === "immutable" /* Immutable */ && assignmentContext !== "initializer") {
+    if (writability === "immutable" /* Immutable */ && assignmentContext === "initializer") {
+      throw new CompileError(
+        immutableRuntimeConstructionError(
+          target.symbol?.name ?? this.describe(target.type)
+        ),
+        statement.pos
+      );
+    }
+    if (writability === "immutable" /* Immutable */) {
       throw new CompileError(
         "Cannot assign because the target's effective storage is immutable.",
         statement.pos
@@ -37016,8 +37326,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           );
         }
         const declared = declaredTarget?.declaredConstructors ?? [];
-        const requiredConstructor = neoScriptRequiredConstructor(declaredTarget);
-        const generatedPositionalCall = requiredConstructor === null && declaredTarget?.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
+        const generatedPositionalCall = declaredTarget !== void 0 && isGeneratedPositionalCall(declaredTarget, expression);
         if (!generatedPositionalCall && (declared.length > 0 || this.context.storedConstructionReplay === true && expression.args.length === 0)) {
           return this.resolveDeclaredConstructor(
             className,
@@ -38510,10 +38819,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           } : {}
         };
       }
-      const writability = this.memberWritability(member, receiver);
-      const entryWritability = member.lookup ? this.lookupEntryWritability(member, receiver) : void 0;
+      const readonlySlot = member.readonlyDeclaration === true;
+      const storageWritability = this.memberWritability(member, receiver);
+      const writability = readonlySlot ? "readOnly" /* ReadOnly */ : storageWritability;
+      const entryWritability = member.lookup ? this.lookupEntryWritability(member, receiver) : readonlySlot ? storageWritability : void 0;
       const userData = this.memberUserData(member, receiver);
-      const entryUserData = member.lookup ? this.lookupEntryUserData(member) : false;
+      const entryUserData = member.lookup ? this.lookupEntryUserData(member) : readonlySlot && userData;
       const lookupWire = member.lookup?.multiselect === true && memberType2.kind === "set" ? {
         type: 9 /* Lookup */,
         required: !isNullable(memberType2),
@@ -38536,6 +38847,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         ...writability ? { writability } : {},
         ...lookupWire ? { wireType: lookupWire } : {},
         ...entryWritability ? { entryWritability } : {},
+        ...readonlySlot && storageWritability ? { initWritability: storageWritability } : {},
         userData,
         entryUserData
       };
@@ -38627,7 +38939,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (member.writability && !member.lookup) {
       return toWritability(member.writability, this.writesUserData);
     }
-    if (!member.writable) return void 0;
+    if (!member.writable && member.readonlyDeclaration !== true)
+      return void 0;
     if (!member.lookup) {
       return member.writability ? toWritability(member.writability, this.writesUserData) : receiver.entryWritability ?? receiver.writability ?? "save" /* Save */;
     }
@@ -38719,6 +39032,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         writability: "readOnly" /* ReadOnly */
       };
     }
+    const readonlyCollection = receiver.symbol?.readonlyDeclaration === true && receiver.initWritability !== void 0 ? {
+      name: receiver.symbol.name,
+      pointer: receiver.pointer,
+      initWritability: receiver.initWritability
+    } : void 0;
     let keyType;
     let valueType;
     let resolvedIndex;
@@ -38735,7 +39053,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           type: nullPropagating ? { ...receiver.type.elementType, nullable: true } : receiver.type.elementType,
           ...nullPropagating ? { optionalChainType: receiver.type.elementType } : {},
           ...receiver.writability ? { writability: receiver.writability } : {},
-          ...receiver.userData ? { userData: true } : {}
+          ...receiver.entryWritability ? { entryWritability: receiver.entryWritability } : {},
+          ...receiver.userData ? { userData: true } : {},
+          ...receiver.entryUserData ? { entryUserData: true } : {},
+          ...readonlyCollection ? { readonlyCollection } : {}
         };
       }
       keyType = { kind: "primitive", name: "int" };
@@ -38770,7 +39091,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       type: nullPropagating ? { ...valueType, nullable: true } : valueType,
       ...nullPropagating ? { optionalChainType: valueType } : {},
       ...receiver.writability ? { writability: receiver.writability } : {},
-      ...receiver.userData ? { userData: true } : {}
+      ...receiver.entryWritability ? { entryWritability: receiver.entryWritability } : {},
+      ...receiver.userData ? { userData: true } : {},
+      ...receiver.entryUserData ? { entryUserData: true } : {},
+      ...readonlyCollection ? { readonlyCollection } : {}
     };
   }
   resolveDictionaryKey(expectedKey, keyAst, scope, pos, requireNonOptional, dictionaryLiteral = false) {
@@ -39658,7 +39982,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveExecutableObjectInitializer(schemaClass2, expression, scope, expected) {
-    const constructed = this.resolveExpression(
+    const settling = this.generatedConstructorSettlingEntries(
+      schemaClass2,
+      expression
+    );
+    const constructed = settling.length > 0 ? this.resolveClassConstructor(
+      schemaClass2.name,
+      { ...expression, initializer: settling },
+      scope,
+      expression.pos,
+      expected
+    ) : this.resolveExpression(
       { ...expression, className: schemaClass2.name, initializer: [] },
       scope,
       expected
@@ -39684,6 +40018,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     const assignments = [];
     const seen = /* @__PURE__ */ new Set();
     for (const entry of expression.initializer ?? []) {
+      if (settling.includes(entry)) continue;
       const key = entry.name.toLowerCase();
       if (seen.has(key)) {
         throw new CompileError(
@@ -39727,6 +40062,23 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       writeRoot: "local"
     };
   }
+  /** Block entries naming a required parameter the positional arguments skip. */
+  generatedConstructorSettlingEntries(schemaClass2, expression) {
+    const signature = schemaClass2.constructorSignature;
+    if (signature === void 0) return [];
+    const generated = isGeneratedPositionalCall(schemaClass2, expression) || (schemaClass2.declaredConstructors?.length ?? 0) === 0 && expression.argumentNames === void 0;
+    if (!generated) return [];
+    const required = new Set(
+      requiredMembersAfterArguments(
+        schemaClass2,
+        signature.parameters,
+        expression.args.length
+      ).map((name) => name.toLowerCase())
+    );
+    return (expression.initializer ?? []).filter(
+      (entry) => required.has(entry.name.toLowerCase())
+    );
+  }
   resolveClassConstructor(className, expression, scope, pos, expected) {
     const schemaClass2 = this.project.typeByName.get(className);
     if (!schemaClass2 || schemaClass2.kind !== "class") {
@@ -39748,7 +40100,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
-    const signature = schemaClass2.constructorSignature ?? (replayingStoredConstruction ? schemaClass2.storedConstructionReplaySignature : void 0);
+    if (schemaClass2.constructorUnavailableReason === "requiredImmutableMember" && !replayingStoredConstruction) {
+      throw new CompileError(
+        `Cannot construct Class '${className}' at runtime; it has a required Immutable member, which only authored values can supply.`,
+        pos
+      );
+    }
+    const signature = replayingStoredConstruction ? schemaClass2.storedConstructionReplaySignature ?? schemaClass2.constructorSignature : schemaClass2.constructorSignature;
     if (!signature) {
       const open = (schemaClass2.typeParameters?.length ?? 0) > 0;
       throw new CompileError(
@@ -39781,16 +40139,21 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
-    const requiredCount = signature.parameters.filter(
-      (parameter3) => parameter3.required
-    ).length;
-    if (expression.argumentNames === void 0 && argumentsList2.length < requiredCount) {
+    const blockKeys = new Set(
+      (expression.initializer ?? []).map((entry) => entry.name.toLowerCase())
+    );
+    const unsettled = requiredMembersAfterArguments(
+      schemaClass2,
+      parameters,
+      argumentsList2.length
+    ).filter((name) => !blockKeys.has(name.toLowerCase()));
+    if (unsettled.length > 0) {
       throw new CompileError(
-        `${className} constructor requires ${requiredCount} argument${requiredCount === 1 ? "" : "s"} but got ${argumentsList2.length}.`,
+        `${className} construction does not set required ${unsettled.length === 1 ? "member" : "members"} ${unsettled.map((name) => `'${name}'`).join(", ")}. Pass each as a constructor argument or set it in an initializer block.`,
         pos
       );
     }
-    if (expression.argumentNames === void 0 && argumentsList2.length > parameters.length) {
+    if (argumentsList2.length > parameters.length) {
       throw new CompileError(
         `${className} constructor accepts at most ${parameters.length} argument${parameters.length === 1 ? "" : "s"} but got ${argumentsList2.length}.`,
         pos
@@ -40106,9 +40469,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           entry.pos
         );
       }
-      if (member.readonlyDeclaration === true) {
+      if (member.writability === "immutable" && this.context.storedConstructionReplay !== true) {
         throw new CompileError(
-          `'${schemaClass2.name}.${member.name}' is readonly and can only be changed through its class default.`,
+          immutableRuntimeConstructionError(member.name),
           entry.pos
         );
       }
@@ -41802,7 +42165,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
-    const writability = receiver.writability;
+    const initializing = receiver.initWritability !== void 0 && this.constructsSlot(receiver.pointer, "ordinary");
+    if (receiver.symbol?.readonlyDeclaration === true && !initializing) {
+      throw new CompileError(readonlyWriteError(receiver.symbol.name), pos);
+    }
+    const writability = initializing ? receiver.initWritability : receiver.writability;
     const readOnlyCollection = (receiver.type.kind === "list" || receiver.type.kind === "dictionary" || receiver.type.kind === "set") && receiver.type.readOnly === true;
     if (!writability || writability === "readOnly" /* ReadOnly */ || writability === "immutable" /* Immutable */ || readOnlyCollection) {
       if (receiver.indexDefinition) {
@@ -41895,7 +42262,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
-    const writability = receiver.writability;
+    const initializing = receiver.initWritability !== void 0 && this.constructsSlot(receiver.pointer, "ordinary");
+    if (receiver.symbol?.readonlyDeclaration === true && !initializing) {
+      throw new CompileError(readonlyWriteError(receiver.symbol.name), pos);
+    }
+    const writability = initializing ? receiver.initWritability : receiver.writability;
     if (writability === "immutable" /* Immutable */) {
       throw new CompileError(
         "Cannot clear an action whose effective storage is immutable.",
@@ -42287,6 +42658,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos
     );
   }
+  /**
+   * Whether a write to this member slot happens while its instance is
+   * constructed: an object initializer entry, or `this.X` directly in a
+   * constructor body.
+   */
+  constructsSlot(pointer, assignmentContext) {
+    if (assignmentContext === "initializer") return true;
+    if (this.context.kind !== "constructor") return false;
+    if (this.lambdaDepth > 0) return false;
+    if (pointer.type !== "keyOf" /* KeyOf */) return false;
+    const receiver = pointer.keyOf.pointer;
+    return receiver.type === "variable" /* Variable */ && receiver.variableId === this.thisVariable.id;
+  }
   writeTargetRoot(pointer, scope) {
     switch (pointer.type) {
       case "variable" /* Variable */:
@@ -42708,6 +43092,20 @@ function variable(id, type, pointer, project) {
     }
   };
 }
+function isGeneratedPositionalCall(target, expression) {
+  return neoScriptRequiredConstructor(target) === null && target.constructorSignature !== void 0 && expression.argumentNames === void 0 && callHasPositionalArguments(expression);
+}
+function requiredMembersAfterArguments(schemaClass2, parameters, positionalCount) {
+  const names = [];
+  for (const parameter3 of parameters.slice(positionalCount)) {
+    if (!parameter3.required) continue;
+    const member = schemaClass2.members.find(
+      (candidate) => candidate.id === parameter3.memberId
+    );
+    names.push(member?.name ?? parameter3.name);
+  }
+  return names;
+}
 function callHasPositionalArguments(expression) {
   return expression.args.some(
     (_, index) => (expression.argumentNames?.[index] ?? null) === null
@@ -44463,31 +44861,29 @@ function attachConstructorSignature(type, environment) {
   for (const binding of genericEnvironment.values()) {
     if (binding.kind === "unbound") return type;
   }
-  const constructorSignature2 = buildNeoScriptConstructorSignature(
-    type.id,
-    type.members,
-    (memberId) => {
-      const declarationMember = environment.members.get(memberId);
-      if (declarationMember?.isReadOnly === true) return null;
-      const member = effectiveConstructorMember(
-        memberId,
-        genericEnvironment,
-        environment
-      );
-      return member ? {
-        required: boolean(member.required, `member ${memberId}.required`),
-        defaultValue: member.defaultValue
-      } : null;
-    }
-  );
-  if (resolvedAllowedStorage(type.id, environment) === "immutable") {
-    return {
-      ...type,
-      storedConstructionReplaySignature: constructorSignature2,
-      constructorUnavailableReason: "immutableOnly"
-    };
-  }
-  return { ...type, constructorSignature: constructorSignature2 };
+  return {
+    ...type,
+    ...buildNeoScriptConstructionSignatures(
+      type.id,
+      type.members,
+      (memberId) => {
+        const member = effectiveConstructorMember(
+          memberId,
+          genericEnvironment,
+          environment
+        );
+        return member ? {
+          required: boolean(member.required, `member ${memberId}.required`),
+          defaultValue: member.defaultValue,
+          immutable: declaredStorage(
+            environment.members.get(memberId),
+            environment.members
+          ) === "immutable"
+        } : null;
+      },
+      resolvedAllowedStorage(type.id, environment) === "immutable"
+    )
+  };
 }
 function resolvedAllowedStorage(classId, environment) {
   const visited = /* @__PURE__ */ new Set();
@@ -44570,6 +44966,20 @@ function inferRootMemberIds(members) {
     user: unique("user")
   };
 }
+function declaredStorage(member, members) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = member;
+  while (current !== void 0 && !seen.has(current)) {
+    seen.add(current);
+    const storage = current.storage;
+    if (storage === "immutable" || storage === "save" || storage === "session" || storage === "writable" || storage === "user") {
+      return storage;
+    }
+    if (typeof current.overrideOf !== "string") return null;
+    current = members.get(current.overrideOf);
+  }
+  return null;
+}
 function effectiveMemberWritability(members, classes, roots) {
   const memberById = /* @__PURE__ */ new Map();
   for (const member of members) {
@@ -44583,16 +44993,6 @@ function effectiveMemberWritability(members, classes, roots) {
       classById.set(schemaClass2.id, schemaClass2);
     }
   }
-  const declaredStorage = (memberId, seen = /* @__PURE__ */ new Set()) => {
-    if (seen.has(memberId)) return null;
-    seen.add(memberId);
-    const member = memberById.get(memberId);
-    if (!member) return null;
-    if (member.storage === "immutable" || member.storage === "save" || member.storage === "session" || member.storage === "writable" || member.storage === "user") {
-      return member.storage;
-    }
-    return typeof member.overrideOf === "string" ? declaredStorage(member.overrideOf, seen) : null;
-  };
   const classExtends = (candidateId, baseId) => {
     const seen = /* @__PURE__ */ new Set();
     let currentId = candidateId;
@@ -44658,7 +45058,7 @@ function effectiveMemberWritability(members, classes, roots) {
   }
   if (typeof roots.user === "string") rootStorage.set(roots.user, "user");
   for (const [memberId, member] of memberById) {
-    const declared = rootStorage.get(memberId) ?? declaredStorage(memberId);
+    const declared = rootStorage.get(memberId) ?? declaredStorage(member, memberById);
     if (declared === "writable") {
       writable.add(memberId);
       continue;
@@ -44816,10 +45216,9 @@ function memberSymbol(member, schemaKey, environment, field) {
     };
   }
   const writable = isReadOnly ? false : kind === "computed" ? computedHasSetter(member, field) : true;
-  const storage = typeof member.storage === "string" ? member.storage : void 0;
+  const storage = declaredStorage(member, environment.members) ?? void 0;
   let writability;
-  if (!writable) writability = "readOnly";
-  else if (kind === "computed") writability = "setter";
+  if (kind === "computed") writability = writable ? "setter" : "readOnly";
   else {
     writability = declaredStorageWritability(
       storage,
@@ -46753,35 +47152,7 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
   if (!isClosedClass(schemaClass2.id, context.vm.classes)) {
     return {};
   }
-  if (resolveAllowedStorage(schemaClass2.id, context.vm.classes) === 1 /* Immutable */) {
-    const signature2 = buildNeoScriptConstructorSignature(
-      schemaClass2.id,
-      members,
-      (memberId) => {
-        const record4 = analyzerMemberById(context, memberId);
-        if (!record4) return null;
-        try {
-          const resolved = substituteMember(
-            record4,
-            genericEnvironment,
-            context.vm.members,
-            resolveAnalyzerMember(context, record4)
-          );
-          return {
-            required: isRequiredMember(resolved),
-            defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0
-          };
-        } catch {
-          return null;
-        }
-      }
-    );
-    return {
-      storedConstructionReplaySignature: signature2,
-      constructorUnavailableReason: "immutableOnly"
-    };
-  }
-  const signature = buildNeoScriptConstructorSignature(
+  return buildNeoScriptConstructionSignatures(
     schemaClass2.id,
     members,
     (memberId) => {
@@ -46796,14 +47167,15 @@ function constructorSignature(schemaClass2, members, context, genericEnvironment
         );
         return {
           required: isRequiredMember(resolved),
-          defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0
+          defaultValue: "defaultValue" in resolved ? resolved.defaultValue : void 0,
+          immutable: declaredMemberStorage(record4.id, context.vm.members) === 1 /* Immutable */
         };
       } catch {
         return null;
       }
-    }
+    },
+    resolveAllowedStorage(schemaClass2.id, context.vm.classes) === 1 /* Immutable */
   );
-  return { constructorSignature: signature };
 }
 function declaredConstructors(schemaClass2, context) {
   const requiredConstructorId2 = schemaClass2.requiredConstructorId;
@@ -46888,6 +47260,7 @@ function memberToSymbol(record4, schemaKey, containingClass, ownerClassId, index
     ...scriptDefinitionLocations2(record4.id, context),
     documentation: getOptionalString(resolved, "docsText") ?? `${record4.name} (${record4.id})`,
     writable: !isReadOnlyMember(record4),
+    ...isReadOnlyMember(record4) ? { readonlyDeclaration: true } : {},
     ...isStaticMember(record4) === true ? { static: true } : {},
     ...symbolWritability(
       record4.id,
@@ -49489,7 +49862,7 @@ async function loadMemberDefaultValueClosure(args) {
       const classId = source.classId ?? member.classId;
       classFields = classSchemas.get(classId);
       if (classFields === void 0) {
-        classFields = mergeStoredInstanceSchema(classId, classes, members);
+        classFields = mergeInstanceSurfaceSchema(classId, classes, members);
         classSchemas.set(classId, classFields);
       }
       env = withStamp(
@@ -50777,6 +51150,11 @@ var BODY_CHILD_PAYLOAD = canonicalJsonStringify({
 });
 
 // ../src/models/project/world-content-sidecar-validation.ts
+var TILE_CLASS_LEVEL_KEYS = worldSystemSchemaFieldsForKind(
+  NeoWorldSystemClassKind.Tile
+).flatMap(
+  (field) => field.mutability === 1 /* ReadOnly */ ? [field.schemaKey] : []
+);
 var WORLD_PLACEMENT_ASSET_KIND = /* @__PURE__ */ new Map([[NeoWorldSystemClassKind.Object, NeoWorldSystemClassKind.Object]]);
 
 // ../src/database/general-function-call-ir-source-recompile.ts
@@ -50794,7 +51172,7 @@ var STRING_TYPE_INFO = {
 };
 
 // ../src/database/project-version-whole-graph-validation.ts
-import { ConvexError as ConvexError4 } from "convex/values";
+import { ConvexError as ConvexError3 } from "convex/values";
 
 // ../src/models/exports/unity-static-members.ts
 var nativePatternMembers = new Set(
@@ -50802,7 +51180,6 @@ var nativePatternMembers = new Set(
 );
 
 // ../convex/projectInterfaceValidation.ts
-import { ConvexError as ConvexError3 } from "convex/values";
 var MEMBER_REQUIREMENT_KINDS = [
   0 /* Optional */,
   1 /* Required */
@@ -55720,7 +56097,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.75.2",
+  cliVersion: "0.76.1",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -57398,7 +57775,7 @@ function buildRootValue(document2, lookups) {
 var MAX_SOURCE_BYTES = 32 * 1024 * 1024;
 
 // ../src/database/client-commit-submit.ts
-import { ConvexError as ConvexError5 } from "convex/values";
+import { ConvexError as ConvexError4 } from "convex/values";
 
 // ../src/common/client-commit-transport.ts
 var INLINE_COMMIT_MAX_PAYLOAD_BYTES = 512 * 1024;
@@ -57482,7 +57859,7 @@ var WORLD_OBJECT_CONTRACT_WORLD_KINDS = /* @__PURE__ */ new Set([
 ]);
 
 // ../src/models/exports/unity-codegen-revision.ts
-var UNITY_CODEGEN_REVISION = "e4a632a177c87244e19da71c9840b8007735773ae5f81578f58ce246ec6cb03d";
+var UNITY_CODEGEN_REVISION = "ac7f9812e3b16cc37d09ba5006316dda6bac23884c83b368a10880bc3f2c765b";
 
 // src/export-cache.ts
 var CACHE_BUILD = JSON.stringify([