@neocompose/cli 0.71.4 → 0.72.0

package/dist/neo.mjs

@@ -43,10 +43,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // ../src/models/members/member-storage.ts
 function isMemberStorageKind(value) {
-  return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 4 /* Writable */;
+  return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 4 /* Writable */ || value === 5 /* User */;
 }
 function isEffectiveMemberStorage(value) {
-  return value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */;
+  return value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 5 /* User */;
 }
 function isClassAllowedStorage(value) {
   if (!isMemberStorageKind(value)) return false;
@@ -57,11 +57,19 @@ function childEffectiveStorage(declared, parent) {
     case 0 /* Inherit */:
       return parent;
     case 4 /* Writable */:
-      return parent === 2 /* Save */ ? 2 /* Save */ : 3 /* Session */;
+      return parent === 2 /* Save */ || parent === 5 /* User */ ? parent : 3 /* Session */;
     default:
       return declared;
   }
 }
+function allowedStorageAdmits(constraint, storage) {
+  if (constraint !== 4 /* Writable */) return storage === constraint;
+  return storage === 2 /* Save */ || storage === 3 /* Session */ || storage === 4 /* Writable */;
+}
+function admittedPlacementStorages(constraint) {
+  if (constraint !== 4 /* Writable */) return [constraint];
+  return [2 /* Save */, 3 /* Session */];
+}
 function constraintDefaultStorage(constraint) {
   if (constraint === null) return 3 /* Session */;
   if (constraint === 4 /* Writable */) {
@@ -84,6 +92,15 @@ function createWritableAncestorLookup(memberById2) {
   };
   return lookup;
 }
+function isChildStorageAllowed(context, child2) {
+  if (child2 === 0 /* Inherit */) return true;
+  if (context === 5 /* User */) return false;
+  if (child2 === 5 /* User */) return false;
+  if (child2 === 2 /* Save */) {
+    return context !== 3 /* Session */;
+  }
+  return true;
+}
 var MemberStorageKind;
 var init_member_storage = __esm({
   "../src/models/members/member-storage.ts"() {
@@ -94,6 +111,7 @@ var init_member_storage = __esm({
       MemberStorageKind3[MemberStorageKind3["Save"] = 2] = "Save";
       MemberStorageKind3[MemberStorageKind3["Session"] = 3] = "Session";
       MemberStorageKind3[MemberStorageKind3["Writable"] = 4] = "Writable";
+      MemberStorageKind3[MemberStorageKind3["User"] = 5] = "User";
       return MemberStorageKind3;
     })(MemberStorageKind || {});
   }
@@ -350,6 +368,255 @@ var init_member_subtree_distribution = __esm({
   }
 });
 
+// node_modules/uuid/dist-node/regex.js
+var regex_default;
+var init_regex = __esm({
+  "node_modules/uuid/dist-node/regex.js"() {
+    regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+  }
+});
+
+// node_modules/uuid/dist-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default;
+var init_validate = __esm({
+  "node_modules/uuid/dist-node/validate.js"() {
+    init_regex();
+    validate_default = validate;
+  }
+});
+
+// node_modules/uuid/dist-node/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
+}
+var parse_default;
+var init_parse = __esm({
+  "node_modules/uuid/dist-node/parse.js"() {
+    init_validate();
+    parse_default = parse;
+  }
+});
+
+// node_modules/uuid/dist-node/stringify.js
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+var byteToHex;
+var init_stringify = __esm({
+  "node_modules/uuid/dist-node/stringify.js"() {
+    byteToHex = [];
+    for (let i2 = 0; i2 < 256; ++i2) {
+      byteToHex.push((i2 + 256).toString(16).slice(1));
+    }
+  }
+});
+
+// node_modules/uuid/dist-node/rng.js
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+var rnds8;
+var init_rng = __esm({
+  "node_modules/uuid/dist-node/rng.js"() {
+    rnds8 = new Uint8Array(16);
+  }
+});
+
+// node_modules/uuid/dist-node/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = new Uint8Array(str.length);
+  for (let i2 = 0; i2 < str.length; ++i2) {
+    bytes[i2] = str.charCodeAt(i2);
+  }
+  return bytes;
+}
+function v35(version, hash, value, namespace, buf, offset) {
+  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
+  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
+  if (typeof namespace === "string") {
+    namespace = parse_default(namespace);
+  }
+  if (namespace?.length !== 16) {
+    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+  }
+  let bytes = new Uint8Array(16 + valueBytes.length);
+  bytes.set(namespaceBytes);
+  bytes.set(valueBytes, namespaceBytes.length);
+  bytes = hash(bytes);
+  bytes[6] = bytes[6] & 15 | version;
+  bytes[8] = bytes[8] & 63 | 128;
+  if (buf) {
+    offset ??= 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i2 = 0; i2 < 16; ++i2) {
+      buf[offset + i2] = bytes[i2];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+var DNS, URL2;
+var init_v35 = __esm({
+  "node_modules/uuid/dist-node/v35.js"() {
+    init_parse();
+    init_stringify();
+    DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+  }
+});
+
+// node_modules/uuid/dist-node/v4.js
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i2 = 0; i2 < 16; ++i2) {
+      buf[offset + i2] = rnds[i2];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default;
+var init_v4 = __esm({
+  "node_modules/uuid/dist-node/v4.js"() {
+    init_rng();
+    init_stringify();
+    v4_default = v4;
+  }
+});
+
+// node_modules/uuid/dist-node/sha1.js
+import { createHash } from "node:crypto";
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return createHash("sha1").update(bytes).digest();
+}
+var sha1_default;
+var init_sha1 = __esm({
+  "node_modules/uuid/dist-node/sha1.js"() {
+    sha1_default = sha1;
+  }
+});
+
+// node_modules/uuid/dist-node/v5.js
+function v5(value, namespace, buf, offset) {
+  return v35(80, sha1_default, value, namespace, buf, offset);
+}
+var v5_default;
+var init_v5 = __esm({
+  "node_modules/uuid/dist-node/v5.js"() {
+    init_sha1();
+    init_v35();
+    v5.DNS = DNS;
+    v5.URL = URL2;
+    v5_default = v5;
+  }
+});
+
+// node_modules/uuid/dist-node/index.js
+var init_dist_node = __esm({
+  "node_modules/uuid/dist-node/index.js"() {
+    init_v4();
+    init_v5();
+  }
+});
+
+// ../src/models/project/project-root-members.ts
+function projectRootMemberIds(project) {
+  return PROJECT_ROOTS.map((root) => project[root.projectField]);
+}
+function buildRootStorageMap(project) {
+  const map = /* @__PURE__ */ new Map();
+  for (const root of PROJECT_ROOTS) {
+    map.set(project[root.projectField], root.storage);
+  }
+  return map;
+}
+function writtenRootStorage(project, memberIds) {
+  const map = /* @__PURE__ */ new Map();
+  for (const root of PROJECT_ROOTS) {
+    const memberId = project[root.projectField];
+    if (memberIds.has(memberId)) map.set(memberId, root.storage);
+  }
+  return map;
+}
+function isProjectRootMember(project, memberId) {
+  return PROJECT_ROOTS.some((root) => project[root.projectField] === memberId);
+}
+function projectRootMembersInDisplayOrder(project) {
+  return PROJECT_ROOTS.map((root) => ({
+    root,
+    memberId: project[root.projectField]
+  }));
+}
+var PROJECT_ROOTS;
+var init_project_root_members = __esm({
+  "../src/models/project/project-root-members.ts"() {
+    "use strict";
+    init_member_storage();
+    PROJECT_ROOTS = [
+      {
+        key: "Assets",
+        choice: "assets",
+        projectField: "rootAssetsMemberId",
+        label: "Assets",
+        storage: 1 /* Immutable */
+      },
+      {
+        key: "Save",
+        choice: "save",
+        projectField: "rootSaveFileMemberId",
+        label: "Save",
+        storage: 2 /* Save */
+      },
+      {
+        key: "Session",
+        choice: "session",
+        projectField: "rootSessionMemberId",
+        label: "Session",
+        storage: 3 /* Session */
+      },
+      {
+        key: "User",
+        choice: "user",
+        projectField: "rootUserMemberId",
+        label: "User",
+        storage: 5 /* User */
+      }
+    ];
+  }
+});
+
 // ../src/models/core/structural-narrow.ts
 function isObject(value) {
   if (typeof value !== "object") return false;
@@ -4977,189 +5244,6 @@ var init_inheritance = __esm({
   }
 });
 
-// node_modules/uuid/dist-node/regex.js
-var regex_default;
-var init_regex = __esm({
-  "node_modules/uuid/dist-node/regex.js"() {
-    regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-  }
-});
-
-// node_modules/uuid/dist-node/validate.js
-function validate(uuid) {
-  return typeof uuid === "string" && regex_default.test(uuid);
-}
-var validate_default;
-var init_validate = __esm({
-  "node_modules/uuid/dist-node/validate.js"() {
-    init_regex();
-    validate_default = validate;
-  }
-});
-
-// node_modules/uuid/dist-node/parse.js
-function parse(uuid) {
-  if (!validate_default(uuid)) {
-    throw TypeError("Invalid UUID");
-  }
-  let v;
-  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
-}
-var parse_default;
-var init_parse = __esm({
-  "node_modules/uuid/dist-node/parse.js"() {
-    init_validate();
-    parse_default = parse;
-  }
-});
-
-// node_modules/uuid/dist-node/stringify.js
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-var byteToHex;
-var init_stringify = __esm({
-  "node_modules/uuid/dist-node/stringify.js"() {
-    byteToHex = [];
-    for (let i2 = 0; i2 < 256; ++i2) {
-      byteToHex.push((i2 + 256).toString(16).slice(1));
-    }
-  }
-});
-
-// node_modules/uuid/dist-node/rng.js
-function rng() {
-  return crypto.getRandomValues(rnds8);
-}
-var rnds8;
-var init_rng = __esm({
-  "node_modules/uuid/dist-node/rng.js"() {
-    rnds8 = new Uint8Array(16);
-  }
-});
-
-// node_modules/uuid/dist-node/v35.js
-function stringToBytes(str) {
-  str = unescape(encodeURIComponent(str));
-  const bytes = new Uint8Array(str.length);
-  for (let i2 = 0; i2 < str.length; ++i2) {
-    bytes[i2] = str.charCodeAt(i2);
-  }
-  return bytes;
-}
-function v35(version, hash, value, namespace, buf, offset) {
-  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
-  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
-  if (typeof namespace === "string") {
-    namespace = parse_default(namespace);
-  }
-  if (namespace?.length !== 16) {
-    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
-  }
-  let bytes = new Uint8Array(16 + valueBytes.length);
-  bytes.set(namespaceBytes);
-  bytes.set(valueBytes, namespaceBytes.length);
-  bytes = hash(bytes);
-  bytes[6] = bytes[6] & 15 | version;
-  bytes[8] = bytes[8] & 63 | 128;
-  if (buf) {
-    offset ??= 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i2 = 0; i2 < 16; ++i2) {
-      buf[offset + i2] = bytes[i2];
-    }
-    return buf;
-  }
-  return unsafeStringify(bytes);
-}
-var DNS, URL2;
-var init_v35 = __esm({
-  "node_modules/uuid/dist-node/v35.js"() {
-    init_parse();
-    init_stringify();
-    DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-    URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
-  }
-});
-
-// node_modules/uuid/dist-node/v4.js
-function v4(options, buf, offset) {
-  if (!buf && !options && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i2 = 0; i2 < 16; ++i2) {
-      buf[offset + i2] = rnds[i2];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default;
-var init_v4 = __esm({
-  "node_modules/uuid/dist-node/v4.js"() {
-    init_rng();
-    init_stringify();
-    v4_default = v4;
-  }
-});
-
-// node_modules/uuid/dist-node/sha1.js
-import { createHash } from "node:crypto";
-function sha1(bytes) {
-  if (Array.isArray(bytes)) {
-    bytes = Buffer.from(bytes);
-  } else if (typeof bytes === "string") {
-    bytes = Buffer.from(bytes, "utf8");
-  }
-  return createHash("sha1").update(bytes).digest();
-}
-var sha1_default;
-var init_sha1 = __esm({
-  "node_modules/uuid/dist-node/sha1.js"() {
-    sha1_default = sha1;
-  }
-});
-
-// node_modules/uuid/dist-node/v5.js
-function v5(value, namespace, buf, offset) {
-  return v35(80, sha1_default, value, namespace, buf, offset);
-}
-var v5_default;
-var init_v5 = __esm({
-  "node_modules/uuid/dist-node/v5.js"() {
-    init_sha1();
-    init_v35();
-    v5.DNS = DNS;
-    v5.URL = URL2;
-    v5_default = v5;
-  }
-});
-
-// node_modules/uuid/dist-node/index.js
-var init_dist_node = __esm({
-  "node_modules/uuid/dist-node/index.js"() {
-    init_v4();
-    init_v5();
-  }
-});
-
 // ../src/models/system-record-id.ts
 function isSystemRecordId(id2) {
   return id2.startsWith(SYSTEM_RECORD_ID_PREFIX);
@@ -8667,11 +8751,7 @@ function assertReadOnlyMembersValid(document) {
       }
     }
   }
-  const rootMemberIds2 = /* @__PURE__ */ new Set([
-    document.project.rootAssetsMemberId,
-    document.project.rootSaveFileMemberId,
-    document.project.rootSessionMemberId
-  ]);
+  const rootMemberIds = new Set(projectRootMemberIds(document.project));
   for (const member of document.members) {
     const resolved = resolveMember(member, document.members);
     if (!isMemberLookupBase(resolved)) continue;
@@ -8690,7 +8770,7 @@ function assertReadOnlyMembersValid(document) {
       );
     }
     const ownerContext = readOnlyOwnerContext(placements);
-    if (rootMemberIds2.has(member.id) || entryMemberIds.has(member.id) || bindingMemberIds.has(member.id)) {
+    if (rootMemberIds.has(member.id) || entryMemberIds.has(member.id) || bindingMemberIds.has(member.id)) {
       throw new Error(
         `Read-only member "${member.name}" (${member.id}) cannot be a root, collection entry template, or generic binding artifact; ${ownerContext}.`
       );
@@ -8961,6 +9041,7 @@ var READ_ONLY_SYNTHETIC_VALUE_ID_PREFIX;
 var init_read_only_members = __esm({
   "../src/models/members/read-only-members.ts"() {
     "use strict";
+    init_project_root_members();
     init_inheritance();
     init_classes();
     init_project_schema_index();
@@ -13052,6 +13133,172 @@ function declaredMemberStorageFromIndex(memberId, memberIndex) {
   );
   return declared ?? 0 /* Inherit */;
 }
+function memberStorageLabel(value) {
+  if (!isMemberStorageKind(value)) return String(value);
+  switch (value) {
+    case 0 /* Inherit */:
+      return "inherit";
+    case 1 /* Immutable */:
+      return "immutable";
+    case 2 /* Save */:
+      return "save";
+    case 3 /* Session */:
+      return "session";
+    case 4 /* Writable */:
+      return "writable";
+    case 5 /* User */:
+      return "user";
+  }
+}
+function constraintLabel(constraint) {
+  return admittedPlacementStorages(constraint).map((storage) => `"${memberStorageLabel(storage)}"`).join(" or ");
+}
+function ownStorage(member) {
+  return member.storage;
+}
+function memberLabel(member, memberId) {
+  if (!member) return `"${memberId}"`;
+  return `"${member.name}" (${memberId})`;
+}
+function validateDocumentStorage(ctx) {
+  const resolver = new EffectiveStorageResolver(ctx);
+  const errors = [];
+  const userClasses = resolver.userClassIds();
+  const classById = new Map(
+    ctx.classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
+  );
+  for (const [rootId, stamped] of ctx.rootStorage) {
+    const root = resolver.member(rootId);
+    if (root === void 0) continue;
+    const declared = root.storage;
+    if (declared !== stamped) {
+      errors.push({
+        message: `Project root member ${memberLabel(root, rootId)} must declare storage "${memberStorageLabel(stamped)}" but declares "${memberStorageLabel(declared)}".`
+      });
+    }
+  }
+  const userClassMemberIds = /* @__PURE__ */ new Set();
+  for (const classId of userClasses) {
+    const schemaClass2 = classById.get(classId);
+    if (schemaClass2 === void 0) continue;
+    for (const memberId of Object.values(schemaClass2.schema)) {
+      userClassMemberIds.add(memberId);
+      const member = resolver.member(memberId);
+      if (member === void 0) continue;
+      const own = ownStorage(member);
+      if (own !== void 0 && own !== 0 /* Inherit */) {
+        errors.push({
+          message: `${resolver.placementLabel(member)}: Members of User classes can't declare storage. They are always User.`
+        });
+      }
+      if (isStaticMember(member) && memberKindSupportsStorage(member.kind)) {
+        errors.push({
+          message: `${resolver.placementLabel(member)}: User classes can't declare static stored members.`
+        });
+      }
+    }
+  }
+  for (const member of ctx.members) {
+    const declared = resolver.declaredStorage(member.id);
+    if (declared === 4 /* Writable */ && isStaticMember(member)) {
+      errors.push({
+        message: `Static member ${memberLabel(member, member.id)} cannot declare storage "writable"; a static member has no placement parent to resolve it against.`
+      });
+    }
+    const own = ownStorage(member);
+    if (own === 1 /* Immutable */ || own === 0 /* Inherit */) {
+      const writableAncestorId = resolver.writableAncestorId(member.id);
+      if (writableAncestorId !== null) {
+        errors.push({
+          message: `Member ${memberLabel(member, member.id)} declares storage "${memberStorageLabel(own)}" but overrides Writable member ${memberLabel(resolver.member(writableAncestorId), writableAncestorId)}; an override of a Writable member may declare "writable", "save", or "session", or omit storage.`
+        });
+      }
+    }
+    if (declared === 0 /* Inherit */) continue;
+    if (ctx.rootStorage.has(member.id)) continue;
+    if (declared === 5 /* User */) {
+      errors.push({
+        message: `${resolver.placementLabel(member)}: Only classes can be constrained to User. Members under \`root.User\` are User already.`
+      });
+      continue;
+    }
+    if (userClassMemberIds.has(member.id)) continue;
+    for (const parentId of resolver.parentMemberIds(member.id)) {
+      for (const context of resolver.effectiveStorages(parentId)) {
+        if (isChildStorageAllowed(context, declared)) continue;
+        errors.push({
+          message: context === 5 /* User */ ? `${resolver.placementLabel(member)}: Members of User classes can't declare storage. They are always User.` : `Member ${memberLabel(member, member.id)} declares storage "${memberStorageLabel(declared)}" but is placed under ${memberLabel(resolver.member(parentId), parentId)} whose effective storage is "${memberStorageLabel(context)}"; "save" persistence cannot outlive a "session" container.`
+        });
+      }
+    }
+  }
+  for (const schemaClass2 of ctx.classes) {
+    if (userClasses.has(schemaClass2.id) && schemaClass2.extendsClassId !== void 0 && !userClasses.has(schemaClass2.extendsClassId)) {
+      const base = classById.get(schemaClass2.extendsClassId);
+      errors.push({
+        message: `User class \`${schemaClass2.name}\` can't extend \`${base?.name ?? schemaClass2.extendsClassId}\`, which isn't a User class.`
+      });
+    }
+    if (schemaClass2.allowedStorage == null) continue;
+    if (schemaClass2.extendsClassId === void 0) continue;
+    const inherited = resolver.allowedStorage(schemaClass2.extendsClassId);
+    if (inherited === null) continue;
+    if (allowedStorageAdmits(inherited, schemaClass2.allowedStorage)) continue;
+    errors.push({
+      message: `Class "${schemaClass2.name}" (${schemaClass2.id}) declares allowedStorage "${memberStorageLabel(schemaClass2.allowedStorage)}" but inherits allowedStorage "${memberStorageLabel(inherited)}" from its extends chain; constraints are narrow-only and may not widen or contradict an inherited value.`
+    });
+  }
+  for (const member of ctx.members) {
+    if (member.kind !== 7 /* Class */) continue;
+    const classId = resolver.resolvedClassId(member.id);
+    if (classId === void 0) continue;
+    const constraint = resolver.allowedStorage(classId);
+    const className = classById.get(classId)?.name ?? classId;
+    for (const effective of resolver.effectiveStorages(member.id)) {
+      if (effective === 5 /* User */ && constraint !== 5 /* User */) {
+        errors.push({
+          message: `\`${resolver.placementLabel(member)}\` is User data, so \`${className}\` needs \`@storage(allowed: .User)\`.`
+        });
+        continue;
+      }
+      if (constraint === null) continue;
+      if (allowedStorageAdmits(constraint, effective)) continue;
+      errors.push({
+        message: `Member ${memberLabel(member, member.id)} places class "${className}" at an effective storage of "${memberStorageLabel(effective)}", but the class's allowedStorage restricts placements to ${constraintLabel(constraint)}.`
+      });
+    }
+  }
+  for (const member of ctx.members) {
+    if (member.kind !== 9 /* Lookup */ && !isMemberLookupBase(member)) {
+      continue;
+    }
+    const collectionId = resolver.resolvedCollectionMemberId(member.id);
+    if (collectionId === void 0) continue;
+    const effective = resolver.effectiveStorages(member.id);
+    const collectionEffective = resolver.effectiveStorages(collectionId);
+    const targetsUser = collectionEffective.has(5 /* User */);
+    if (effective.has(5 /* User */)) {
+      for (const storage of collectionEffective) {
+        if (storage === 5 /* User */) continue;
+        errors.push({
+          message: `${resolver.placementLabel(member)}: User lookups can only target collections under \`root.User\`.`
+        });
+        break;
+      }
+    }
+    if (targetsUser && (effective.has(2 /* Save */) || effective.has(1 /* Immutable */))) {
+      errors.push({
+        message: `${resolver.placementLabel(member)}: Save data can't look up \`root.User\`, because the user file isn't part of the save.`
+      });
+    }
+    if (!effective.has(2 /* Save */)) continue;
+    if (!collectionEffective.has(3 /* Session */)) continue;
+    errors.push({
+      message: `Lookup member ${memberLabel(member, member.id)} is Save-effective but targets collection ${memberLabel(resolver.member(collectionId), collectionId)} which is Session-effective; a persisted selection cannot reference session-scoped values.`
+    });
+  }
+  return errors;
+}
 var EffectiveStorageResolver;
 var init_effective_storage = __esm({
   "../src/models/members/effective-storage.ts"() {
@@ -13059,7 +13306,6 @@ var init_effective_storage = __esm({
     init_member_storage();
     init_member_kinds();
     init_structural_narrow();
-    init_classes();
     init_inheritance();
     init_project_schema_index();
     EffectiveStorageResolver = class {
@@ -13076,6 +13322,38 @@ var init_effective_storage = __esm({
         (id2) => this.schemaIndex.member(id2)
       );
       resolving = /* @__PURE__ */ new Set();
+      allowedByClassId = /* @__PURE__ */ new Map();
+      userClasses;
+      /**
+       * `resolveAllowedStorage` over this context, memoized along each extends
+       * chain so a whole-document pass stays O(classes).
+       */
+      allowedStorage(classId) {
+        const cached = this.allowedByClassId.get(classId);
+        if (cached !== void 0) return cached;
+        this.allowedByClassId.set(classId, null);
+        const schemaClass2 = this.schemaIndex.classesById.get(classId);
+        let resolved = null;
+        if (schemaClass2?.allowedStorage != null) {
+          resolved = schemaClass2.allowedStorage;
+        } else if (schemaClass2?.extendsClassId !== void 0) {
+          resolved = this.allowedStorage(schemaClass2.extendsClassId);
+        }
+        this.allowedByClassId.set(classId, resolved);
+        return resolved;
+      }
+      /** P104 §1.3: classes whose resolved `allowedStorage` is `User`. */
+      userClassIds() {
+        if (this.userClasses === void 0) {
+          this.userClasses = /* @__PURE__ */ new Set();
+          for (const schemaClass2 of this.ctx.classes) {
+            if (this.allowedStorage(schemaClass2.id) === 5 /* User */) {
+              this.userClasses.add(schemaClass2.id);
+            }
+          }
+        }
+        return this.userClasses;
+      }
       /** Declared storage of `memberId`, resolved through the extends chain. */
       declaredStorage(memberId) {
         return declaredMemberStorageFromIndex(
@@ -13119,7 +13397,7 @@ var init_effective_storage = __esm({
               result.add(declared);
             } else if (isStaticMember(this.schemaIndex.member(memberId))) {
               const declaringClassId = this.schemaIndex.firstSchemaPlacement(memberId)?.ownerClass.id;
-              const constraint = declaringClassId === void 0 ? null : resolveAllowedStorage(declaringClassId, this.ctx.classes);
+              const constraint = declaringClassId === void 0 ? null : this.allowedStorage(declaringClassId);
               result.add(
                 childEffectiveStorage(
                   declared,
@@ -13222,6 +13500,11 @@ var init_effective_storage = __esm({
       member(memberId) {
         return this.schemaIndex.member(memberId);
       }
+      /** `Owner.Member` for a schema member, else the member's own name. */
+      placementLabel(member) {
+        const owner = this.schemaIndex.firstSchemaPlacement(member.id)?.ownerClass;
+        return owner === void 0 ? member.name : `${owner.name}.${member.name}`;
+      }
       buildParentEdges() {
         const addEdge = (childId, parentId) => {
           const existing = this.parentIdsByMemberId.get(childId);
@@ -23445,6 +23728,189 @@ var init_project = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/project-source-lifecycle-hooks.ts
+function isUnityLifecycleInterfaceName(name) {
+  return name.startsWith(UNITY_LIFECYCLE_INTERFACE_PREFIX);
+}
+function isScriptRuntimeInterface(declaration) {
+  const kind = declaration.annotations.find((annotation2) => annotation2.name === "system")?.arguments.find((argument2) => argument2.name === "kind")?.text.trim();
+  return kind === ".ScriptRuntime";
+}
+function lifecycleHooksByMemberName(interfaces) {
+  const hooks = /* @__PURE__ */ new Map();
+  for (const declaration of interfaces) {
+    if (!isScriptRuntimeInterface(declaration)) continue;
+    for (const member of declaration.members) {
+      if (member.kind !== "function") continue;
+      hooks.set(member.name.toLowerCase(), {
+        interfaceName: declaration.name,
+        member,
+        ...declaration.docsText === void 0 ? {} : { docsText: declaration.docsText },
+        unity: isUnityLifecycleInterfaceName(declaration.name)
+      });
+    }
+  }
+  return hooks;
+}
+function reservedLifecycleMemberMessage(memberName, interfaceName, owner) {
+  const fix = owner === "class" ? "Implement the interface with a public method" : "Extend the interface";
+  return `'${memberName}' is reserved for '${interfaceName}'. ${fix}, or rename the member.`;
+}
+var NEO_LIFECYCLE_OBJECT_CLASS_NAME, UNITY_LIFECYCLE_INTERFACE_PREFIX;
+var init_project_source_lifecycle_hooks = __esm({
+  "../packages/neoscript-language/src/project-source-lifecycle-hooks.ts"() {
+    "use strict";
+    NEO_LIFECYCLE_OBJECT_CLASS_NAME = "NeoObjectBase";
+    UNITY_LIFECYCLE_INTERFACE_PREFIX = "INeoUnity";
+  }
+});
+
+// ../packages/neoscript-language/src/user-safe-types.ts
+function userUnsafeTypeName(type, project) {
+  return userSafeTypeCheck(project).unsafeName(type);
+}
+function userSafeTypeCheck(project) {
+  let check2 = checks.get(project);
+  if (check2 === void 0) {
+    check2 = new UserSafeTypeCheck(project);
+    checks.set(project, check2);
+  }
+  return check2;
+}
+function userClassSignatureViolation(userClass, project) {
+  const check2 = userSafeTypeCheck(project);
+  for (const member of userClass.members) {
+    if (member.inheritedFrom !== void 0) continue;
+    const typeName = check2.symbolUnsafeName(member);
+    if (typeName !== null) return { memberName: member.name, typeName };
+  }
+  for (const constructor2 of userClass.declaredConstructors ?? []) {
+    for (const parameter4 of constructor2.parameters) {
+      const typeName = check2.unsafeName(parameter4.type);
+      if (typeName !== null) return { memberName: null, typeName };
+    }
+  }
+  return null;
+}
+function userUnsafeTypeMessage(typeName, site) {
+  return `User code can't use \`${typeName}\` in ${site}, because it isn't a User class.`;
+}
+var USER_DATA_WRITE_ERROR, checks, UserSafeTypeCheck;
+var init_user_safe_types = __esm({
+  "../packages/neoscript-language/src/user-safe-types.ts"() {
+    "use strict";
+    init_project_source_lifecycle_hooks();
+    USER_DATA_WRITE_ERROR = "Only User code can change User data. C# changes it through the generated user client.";
+    checks = /* @__PURE__ */ new WeakMap();
+    UserSafeTypeCheck = class {
+      constructor(project) {
+        this.project = project;
+      }
+      project;
+      /** Final interface verdicts. */
+      interfaces = /* @__PURE__ */ new Map();
+      /**
+       * Interfaces whose verdict waits on their cycle (Tarjan's SCC stack),
+       * by stack position. One on the stack reads as safe until its cycle ends.
+       */
+      pending = /* @__PURE__ */ new Map();
+      stack = [];
+      /** The lowest stack position the current interface's check consulted. */
+      lowestConsulted = Infinity;
+      symbolUnsafeName(symbol) {
+        for (const parameter4 of symbol.parameters ?? []) {
+          const name = this.unsafeName(parameter4.type);
+          if (name !== null) return name;
+        }
+        if (symbol.returnType !== void 0) {
+          const name = this.unsafeName(symbol.returnType);
+          if (name !== null) return name;
+        }
+        return this.unsafeName(symbol.type);
+      }
+      unsafeName(type) {
+        switch (type.kind) {
+          case "primitive":
+            return null;
+          case "typeParameter":
+            return type.constraint === void 0 ? null : this.unsafeName(type.constraint);
+          case "list":
+          case "set":
+            return this.unsafeName(type.elementType);
+          case "dictionary":
+            return this.unsafeName(type.keyType) ?? this.unsafeName(type.valueType);
+          case "delegate":
+            return this.firstUnsafe(type.parameterTypes) ?? this.unsafeName(type.returnType);
+          case "action":
+            return this.firstUnsafe(type.parameterTypes);
+          case "named":
+            return this.namedUnsafeName(type.typeId) ?? this.firstUnsafe(type.typeArguments ?? []);
+        }
+      }
+      firstUnsafe(types) {
+        for (const type of types) {
+          const name = this.unsafeName(type);
+          if (name !== null) return name;
+        }
+        return null;
+      }
+      namedUnsafeName(typeId) {
+        const named = this.project.typeById.get(typeId);
+        if (named === void 0) return null;
+        switch (named.kind) {
+          case "enum":
+          case "builtin":
+            return null;
+          case "class":
+            return named.userClass === true ? null : named.name;
+          case "synthetic":
+            return named.name;
+          case "interface":
+            return this.interfaceUnsafeName(named);
+        }
+      }
+      // An interface is unsafe when it reaches an unsafe type, so a cycle alone
+      // proves nothing. Interfaces in one cycle reach each other and share a
+      // verdict, settled once the cycle's first interface finishes; each
+      // interface is scanned once.
+      interfaceUnsafeName(named) {
+        if (isUnityLifecycleInterfaceName(named.name)) return named.name;
+        const cached = this.interfaces.get(named.id);
+        if (cached !== void 0) return cached;
+        const pendingAt = this.pending.get(named.id);
+        if (pendingAt !== void 0) {
+          this.lowestConsulted = Math.min(this.lowestConsulted, pendingAt);
+          return null;
+        }
+        const position = this.stack.length;
+        this.stack.push(named);
+        this.pending.set(named.id, position);
+        const outerLowest = this.lowestConsulted;
+        this.lowestConsulted = Infinity;
+        let unsafe = false;
+        for (const member of named.members) {
+          if (this.symbolUnsafeName(member) === null) continue;
+          unsafe = true;
+          break;
+        }
+        if (unsafe || this.lowestConsulted >= position) {
+          this.settleFrom(position, unsafe);
+          this.lowestConsulted = outerLowest;
+        } else {
+          this.lowestConsulted = Math.min(outerLowest, this.lowestConsulted);
+        }
+        return unsafe ? named.name : null;
+      }
+      settleFrom(position, unsafe) {
+        for (const settled of this.stack.splice(position)) {
+          this.pending.delete(settled.id);
+          this.interfaces.set(settled.id, unsafe ? settled.name : null);
+        }
+      }
+    };
+  }
+});
+
 // ../packages/neoscript-language/src/source-map.ts
 function createNeoScriptSourceMap(code, fileText, range2, source, thisAlias) {
   const text = typeof fileText === "string" ? new SourceText(fileText) : fileText;
@@ -25786,8 +26252,10 @@ function namedPrimitive(name) {
       return null;
   }
 }
-function toWritability(value) {
+function toWritability(value, writesUserData) {
   switch (value) {
+    case "user":
+      return writesUserData ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
     case "save":
       return "save" /* Save */;
     case "session":
@@ -26069,6 +26537,7 @@ var init_strict_resolver = __esm({
     init_declared_constructors();
     init_language_spec();
     init_project();
+    init_user_safe_types();
     init_strict_ast();
     init_strict_compile_error();
     init_strict_ir();
@@ -26244,6 +26713,9 @@ var init_strict_resolver = __esm({
         };
         this.debugPosition = sourcePositionMapper(options.source);
         this.project = projectIndex ?? createProjectIndex(context.project);
+        const lexicalClass = context.declaringType === void 0 ? context.thisClass : context.declaringType;
+        this.userClassCode = lexicalClass?.kind === "named" && this.project.typeById.get(lexicalClass.typeId)?.userClass === true;
+        this.writesUserData = this.userClassCode || context.projectSourceKind === "spec";
         this.listenerParameters = createListenerAnnotationProvider(
           this.project,
           context
@@ -26260,6 +26732,7 @@ var init_strict_resolver = __esm({
         const rootSymbol = context.project.roots.find(
           (candidate) => candidate.name === "root"
         );
+        this.rootTypeId = rootSymbol?.type.kind === "named" ? rootSymbol.type.typeId : null;
         this.rootVariable = variable(
           "__root__",
           rootSymbol?.type ?? unknown,
@@ -26315,6 +26788,11 @@ var init_strict_resolver = __esm({
       functionControlBoundaries = [];
       debugSource;
       inferredExpressionReturnType;
+      /** P104 §3.1. User class bodies reach only `root.User`. */
+      userClassCode;
+      rootTypeId;
+      /** P104 §3.1. User class and test bodies may write User data. */
+      writesUserData;
       initialScope() {
         const scope = new Scope(null, this.options.onFlowScope !== void 0);
         scope.define(
@@ -27844,6 +28322,9 @@ var init_strict_resolver = __esm({
             statement.pos
           );
         }
+        if (writability === "readOnly" /* ReadOnly */ && target.userData) {
+          throw new CompileError(USER_DATA_WRITE_ERROR, statement.pos);
+        }
         if (writability === "readOnly" /* ReadOnly */) {
           throw new CompileError(
             `Cannot assign to a read-only ${this.describe(target.type)} value.`,
@@ -28037,7 +28518,7 @@ var init_strict_resolver = __esm({
             statement.pos
           );
         }
-        const writability = observed.writability;
+        const writability = observed.userData ? "runtime" /* Runtime */ : observed.writability;
         if (writability !== "save" /* Save */ && writability !== "session" /* Session */ && writability !== "runtime" /* Runtime */ && writability !== "local" /* Local */) {
           throw new CompileError(
             "OnChanged requires a member whose storage is writable at gameplay runtime.",
@@ -28647,6 +29128,16 @@ var init_strict_resolver = __esm({
               expression.pos
             );
             const declaredTarget = this.project.typeByName.get(className);
+            if (declaredTarget !== void 0) {
+              this.assertUserSafe(
+                { kind: "named", typeId: declaredTarget.id },
+                "a `new` expression",
+                expression.pos
+              );
+            }
+            if (declaredTarget?.userClass === true && !this.writesUserData && this.context.storedConstructionReplay !== true) {
+              throw new CompileError(USER_DATA_WRITE_ERROR, expression.pos);
+            }
             if (declaredTarget?.kind === "class" && (expression.initializer?.length ?? 0) > 0 && this.context.storedConstructionReplay !== true) {
               return this.resolveExecutableObjectInitializer(
                 declaredTarget,
@@ -29835,7 +30326,7 @@ var init_strict_resolver = __esm({
             type: member.type,
             symbol: member,
             ...member.writable ? {
-              writability: member.writability ? toWritability(member.writability) : "setter" /* Setter */
+              writability: member.writability ? toWritability(member.writability, this.writesUserData) : "setter" /* Setter */
             } : {}
           };
         }
@@ -29846,7 +30337,9 @@ var init_strict_resolver = __esm({
           },
           type: member.type,
           symbol: member,
-          ...member.writability ? { writability: toWritability(member.writability) } : {}
+          ...member.writability ? {
+            writability: toWritability(member.writability, this.writesUserData)
+          } : {}
         };
       }
       resolveMemberNatural(receiverAst, name, scope, pos, optional2, receiverValue) {
@@ -29916,6 +30409,11 @@ var init_strict_resolver = __esm({
           }
           const staticType = this.project.typeByName.get(receiverAst.name);
           if (staticType && staticType.kind !== "enum") {
+            this.assertUserSafe(
+              { kind: "named", typeId: staticType.id },
+              "a static receiver",
+              pos
+            );
             if (optional2) {
               throw new CompileError(
                 `Optional chaining is not valid on type receiver '${staticType.name}'.`,
@@ -30094,6 +30592,9 @@ var init_strict_resolver = __esm({
             );
           }
           this.assertMemberAccessible(type, member, pos);
+          if (this.userClassCode && type.id === this.rootTypeId && member.writability !== "user") {
+            throw new CompileError("User code can only read `root.User`.", pos);
+          }
           if (member.static === true) {
             throw new CompileError(
               `Static member '${type.name}.${name}' must be accessed through the type name, not an instance.`,
@@ -30123,12 +30624,14 @@ var init_strict_resolver = __esm({
               ...nullPropagating ? { optionalChainType: memberType2 } : {},
               symbol: member,
               ...member.writable ? {
-                writability: member.writability ? toWritability(member.writability) : "setter" /* Setter */
+                writability: member.writability ? toWritability(member.writability, this.writesUserData) : "setter" /* Setter */
               } : {}
             };
           }
           const writability = this.memberWritability(member, receiver);
           const entryWritability = member.lookup ? this.lookupEntryWritability(member, receiver) : void 0;
+          const userData = this.memberUserData(member, receiver);
+          const entryUserData = member.lookup ? this.lookupEntryUserData(member) : false;
           const lookupWire = member.lookup?.multiselect === true && memberType2.kind === "set" ? {
             type: 9 /* Lookup */,
             required: !isNullable(memberType2),
@@ -30150,7 +30653,9 @@ var init_strict_resolver = __esm({
             symbol: member,
             ...writability ? { writability } : {},
             ...lookupWire ? { wireType: lookupWire } : {},
-            ...entryWritability ? { entryWritability } : {}
+            ...entryWritability ? { entryWritability } : {},
+            userData,
+            entryUserData
           };
         }
         throw new CompileError(
@@ -30236,20 +30741,33 @@ var init_strict_resolver = __esm({
       }
       memberWritability(member, receiver) {
         if (member.writability && !member.lookup) {
-          return toWritability(member.writability);
+          return toWritability(member.writability, this.writesUserData);
         }
         if (!member.writable) return void 0;
         if (!member.lookup) {
-          return member.writability ? toWritability(member.writability) : receiver.entryWritability ?? receiver.writability ?? "save" /* Save */;
+          return member.writability ? toWritability(member.writability, this.writesUserData) : receiver.entryWritability ?? receiver.writability ?? "save" /* Save */;
+        }
+        return member.writability ? toWritability(member.writability, this.writesUserData) : receiver.writability ?? "save" /* Save */;
+      }
+      /** Mirrors {@link memberWritability}'s inheritance for P104 User data. */
+      memberUserData(member, receiver) {
+        if (member.writability) return member.writability === "user";
+        if (member.lookup || receiver.entryWritability === void 0) {
+          return receiver.userData === true;
         }
-        return member.writability ? toWritability(member.writability) : receiver.writability ?? "save" /* Save */;
+        return receiver.entryUserData === true;
+      }
+      lookupEntryUserData(member) {
+        if (!member.lookup) return false;
+        const collectionWritability = member.lookup.collectionWritability ?? this.project.symbolById.get(member.lookup.collectionMemberId)?.writability;
+        return collectionWritability === "user";
       }
       lookupEntryWritability(member, receiver) {
         if (!member.lookup) return "readOnly" /* ReadOnly */;
         const target = this.project.symbolById.get(
           member.lookup.collectionMemberId
         );
-        const targetWritability = member.lookup.collectionWritability ? toWritability(member.lookup.collectionWritability) : target?.writability ? toWritability(target.writability) : target?.writable ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
+        const targetWritability = member.lookup.collectionWritability ? toWritability(member.lookup.collectionWritability, this.writesUserData) : target?.writability ? toWritability(target.writability, this.writesUserData) : target?.writable ? "runtime" /* Runtime */ : "readOnly" /* ReadOnly */;
         if (receiver.writability === "immutable" /* Immutable */) {
           if (targetWritability === "save" /* Save */) {
             return "immutableToSaveLookup" /* ImmutableToSaveLookup */;
@@ -30270,7 +30788,8 @@ var init_strict_resolver = __esm({
           },
           type: optional2 ? { ...type, nullable: true } : type,
           ...optional2 ? { optionalChainType: type } : {},
-          ...receiver.writability ? { writability: receiver.writability } : {}
+          ...receiver.writability ? { writability: receiver.writability } : {},
+          ...receiver.userData ? { userData: true } : {}
         };
       }
       resolveIndex(receiverAst, indexAst, scope, pos, optional2) {
@@ -30331,7 +30850,8 @@ var init_strict_resolver = __esm({
               },
               type: nullPropagating ? { ...receiver.type.elementType, nullable: true } : receiver.type.elementType,
               ...nullPropagating ? { optionalChainType: receiver.type.elementType } : {},
-              ...receiver.writability ? { writability: receiver.writability } : {}
+              ...receiver.writability ? { writability: receiver.writability } : {},
+              ...receiver.userData ? { userData: true } : {}
             };
           }
           keyType = { kind: "primitive", name: "int" };
@@ -30365,7 +30885,8 @@ var init_strict_resolver = __esm({
           },
           type: nullPropagating ? { ...valueType, nullable: true } : valueType,
           ...nullPropagating ? { optionalChainType: valueType } : {},
-          ...receiver.writability ? { writability: receiver.writability } : {}
+          ...receiver.writability ? { writability: receiver.writability } : {},
+          ...receiver.userData ? { userData: true } : {}
         };
       }
       resolveDictionaryKey(expectedKey, keyAst, scope, pos, requireNonOptional, dictionaryLiteral = false) {
@@ -30769,6 +31290,11 @@ var init_strict_resolver = __esm({
           }
           const staticType = this.project.typeByName.get(callee.receiver.name);
           if (staticType && staticType.kind !== "enum") {
+            this.assertUserSafe(
+              { kind: "named", typeId: staticType.id },
+              "a static receiver",
+              pos
+            );
             if (callee.optional) {
               throw new CompileError(
                 `Optional chaining is not valid on type receiver '${staticType.name}'.`,
@@ -32917,6 +33443,9 @@ var init_strict_resolver = __esm({
        */
       resolveActionCall(action, actionType, expression, scope) {
         this.assertActionControlAccessible(action, "invoke", expression.pos);
+        if (action.userData && action.writability === "readOnly" /* ReadOnly */) {
+          throw new CompileError(USER_DATA_WRITE_ERROR, expression.pos);
+        }
         if (expression.callee.kind === "member" && expression.callee.optional) {
           throw new CompileError(
             `${this.describe(actionType)} is never null, so optional-chained invocation is not supported.`,
@@ -33074,6 +33603,11 @@ var init_strict_resolver = __esm({
             expression.callee.receiver.name
           );
           if (staticType && staticType.kind !== "enum") {
+            this.assertUserSafe(
+              { kind: "named", typeId: staticType.id },
+              "a static receiver",
+              expression.pos
+            );
             if (expression.callee.optional) {
               throw new CompileError(
                 `Optional chaining is not valid on type receiver '${staticType.name}'.`,
@@ -33172,6 +33706,9 @@ var init_strict_resolver = __esm({
               pos
             );
           }
+          if (writability === "readOnly" /* ReadOnly */ && receiver.userData) {
+            throw new CompileError(USER_DATA_WRITE_ERROR, pos);
+          }
           throw new CompileError(
             writability === "immutable" /* Immutable */ ? "Cannot mutate a collection whose effective storage is immutable." : "Cannot mutate a read-only collection value.",
             pos
@@ -33266,6 +33803,9 @@ var init_strict_resolver = __esm({
             pos
           );
         }
+        if (writability === "readOnly" /* ReadOnly */ && receiver.userData) {
+          throw new CompileError(USER_DATA_WRITE_ERROR, pos);
+        }
         if (writability === "readOnly" /* ReadOnly */) {
           throw new CompileError("Cannot clear a read-only action.", pos);
         }
@@ -33613,7 +34153,17 @@ var init_strict_resolver = __esm({
         );
       }
       resolveType(type) {
-        return resolveNeoScriptType(type, this.context, this.project);
+        const resolved = resolveNeoScriptType(type, this.context, this.project);
+        this.assertUserSafe(resolved, "a type annotation", type.pos);
+        return resolved;
+      }
+      /** P104 §3.2. User code names only User-safe types. */
+      assertUserSafe(type, site, pos) {
+        if (!this.userClassCode) return;
+        const unsafe = userUnsafeTypeName(type, this.project);
+        if (unsafe !== null) {
+          throw new CompileError(userUnsafeTypeMessage(unsafe, site), pos);
+        }
       }
       /**
        * P43 §7.1. A constructor body builds the value it is handed; every other
@@ -33779,7 +34329,12 @@ var init_strict_resolver = __esm({
             pointer: { type: "variable" /* Variable */, variableId: symbol.id },
             type: symbol.type,
             symbol,
-            ...symbol.writability ? { writability: toWritability(symbol.writability) } : {}
+            ...symbol.writability ? {
+              writability: toWritability(
+                symbol.writability,
+                this.writesUserData
+              )
+            } : {}
           };
         }
         return literal(symbol.type, null);
@@ -34151,14 +34706,16 @@ var init_project_schema_contract_generated = __esm({
           "Immutable",
           "Save",
           "Session",
-          "Writable"
+          "Writable",
+          "User"
         ],
         "NeoAllowedStorage": [
           "Any",
           "Immutable",
           "Save",
           "Session",
-          "Writable"
+          "Writable",
+          "User"
         ],
         "NeoListKind": [
           "Ordered",
@@ -37788,6 +38345,15 @@ var init_project_source_settlement = __esm({
 });
 
 // ../packages/neoscript-language/src/project-root.ts
+function projectRootSlotCountError(slots) {
+  const predatesUser = slots.length === PROJECT_ROOT_SOURCE_SLOTS.length - 1 && slots.every(
+    (slot, index) => slot.name === PROJECT_ROOT_SOURCE_SLOTS[index].name
+  );
+  if (predatesUser) {
+    return "Root.neo predates the User root. Run `neo pull` to update Root.neo.";
+  }
+  return "Root must contain exactly the protected Assets, Save, Session, and User members in canonical order.";
+}
 function parseProjectRootInitializer(source) {
   if (lastRootParse?.source === source) return lastRootParse.slots;
   const slots = parseProjectRootEnvelope(source);
@@ -37926,7 +38492,8 @@ var init_project_root = __esm({
     PROJECT_ROOT_SOURCE_SLOTS = [
       { name: "Assets", type: "Assets", storage: "Immutable" },
       { name: "Save", type: "Save", storage: "Save" },
-      { name: "Session", type: "Session", storage: "Session" }
+      { name: "Session", type: "Session", storage: "Session" },
+      { name: "User", type: "User", storage: "User" }
     ];
   }
 });
@@ -38237,8 +38804,28 @@ function validateDeclaration(uri, declaration, documentKind, environment, diagno
   }
   if (declaration.kind === "class") {
     validateRetiredParameterReads(uri, declaration, scope, diagnostics);
+    validateUserClassSignatures(uri, declaration, environment, diagnostics);
   }
 }
+function validateUserClassSignatures(uri, declaration, environment, diagnostics) {
+  const type = environment.projectIndex.typeByName.get(declaration.name);
+  if (type?.userClass !== true) return;
+  const violation = userClassSignatureViolation(type, environment.projectIndex);
+  if (violation === null) return;
+  const member = declaration.members.find(
+    (candidate) => candidate.name === violation.memberName
+  );
+  pushDiagnostic(
+    diagnostics,
+    uri,
+    member?.nameRange ?? declaration.nameRange,
+    "user-unsafe-type",
+    userUnsafeTypeMessage(
+      violation.typeName,
+      violation.memberName === null ? `a constructor of \`${declaration.name}\`` : `\`${declaration.name}.${violation.memberName}\``
+    )
+  );
+}
 function validateRetiredParameterReads(uri, declaration, scope, diagnostics) {
   if (declaration.headerParameters !== void 0) return;
   const retired = /* @__PURE__ */ new Set();
@@ -38470,7 +39057,7 @@ function validateProjectRootGlobal(uri, declaration, environment, diagnostics) {
       uri,
       declaration.initializer.range,
       "protected-root-envelope",
-      "Root must contain exactly the protected Assets, Save, and Session members in canonical order."
+      projectRootSlotCountError(slots)
     );
     return;
   }
@@ -40740,6 +41327,7 @@ var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
     init_project();
+    init_user_safe_types();
     init_strict_resolver();
     init_reference_argument();
     init_project_source_ast();
@@ -42375,45 +42963,12 @@ var init_project_source_script_compiler = __esm({
     PRIMITIVE_NAMES = new Set(PRIMITIVE_NAME_LIST);
     STORAGE_WRITABILITY = {
       Save: "save",
-      Session: "session"
+      Session: "session",
+      User: "user"
     };
   }
 });
 
-// ../packages/neoscript-language/src/project-source-lifecycle-hooks.ts
-function isScriptRuntimeInterface(declaration) {
-  const kind = declaration.annotations.find((annotation2) => annotation2.name === "system")?.arguments.find((argument2) => argument2.name === "kind")?.text.trim();
-  return kind === ".ScriptRuntime";
-}
-function lifecycleHooksByMemberName(interfaces) {
-  const hooks = /* @__PURE__ */ new Map();
-  for (const declaration of interfaces) {
-    if (!isScriptRuntimeInterface(declaration)) continue;
-    for (const member of declaration.members) {
-      if (member.kind !== "function") continue;
-      hooks.set(member.name.toLowerCase(), {
-        interfaceName: declaration.name,
-        member,
-        ...declaration.docsText === void 0 ? {} : { docsText: declaration.docsText },
-        unity: declaration.name.startsWith(UNITY_LIFECYCLE_INTERFACE_PREFIX)
-      });
-    }
-  }
-  return hooks;
-}
-function reservedLifecycleMemberMessage(memberName, interfaceName, owner) {
-  const fix = owner === "class" ? "Implement the interface with a public method" : "Extend the interface";
-  return `'${memberName}' is reserved for '${interfaceName}'. ${fix}, or rename the member.`;
-}
-var NEO_LIFECYCLE_OBJECT_CLASS_NAME, UNITY_LIFECYCLE_INTERFACE_PREFIX;
-var init_project_source_lifecycle_hooks = __esm({
-  "../packages/neoscript-language/src/project-source-lifecycle-hooks.ts"() {
-    "use strict";
-    NEO_LIFECYCLE_OBJECT_CLASS_NAME = "NeoObjectBase";
-    UNITY_LIFECYCLE_INTERFACE_PREFIX = "INeoUnity";
-  }
-});
-
 // ../packages/neoscript-language/src/project-source-type-checker.ts
 function validateProjectSourceTypes(documents) {
   const diagnostics = [];
@@ -44729,8 +45284,8 @@ function collectFlowSymbols(uri, content, ownerName, scopeRange, symbols, diagno
   }
 }
 function collectSymbol(uri, kind, name, range2, annotations, ownerName, symbols, diagnostics, scopeRange, detail, callable2, documentation, staticMember) {
-  const memberLabel2 = kind === "member" || kind === "enumOption" || kind === "graphChild";
-  const reserved = memberLabel2 ? isNeoProjectMemberReservedName(name) : isNeoProjectReservedName(name);
+  const memberLabel3 = kind === "member" || kind === "enumOption" || kind === "graphChild";
+  const reserved = memberLabel3 ? isNeoProjectMemberReservedName(name) : isNeoProjectReservedName(name);
   if (reserved) {
     diagnostics.push({
       uri,
@@ -46198,7 +46753,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.71.4",
+      cliVersion: "0.72.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -46544,8 +47099,22 @@ var init_registry = __esm({
       sdkDeclarations: {
         attributes: {
           enums: {
-            NeoStorage: ["Inherit", "Immutable", "Save", "Session", "Writable"],
-            NeoAllowedStorage: ["Any", "Immutable", "Save", "Session", "Writable"],
+            NeoStorage: [
+              "Inherit",
+              "Immutable",
+              "Save",
+              "Session",
+              "Writable",
+              "User"
+            ],
+            NeoAllowedStorage: [
+              "Any",
+              "Immutable",
+              "Save",
+              "Session",
+              "Writable",
+              "User"
+            ],
             NeoListKind: ["Ordered", "Unordered"],
             NeoDictionaryKeyKind: ["String", "Enum"],
             NeoClassVisibility: ["Visible", "Hidden"],
@@ -50655,7 +51224,9 @@ var init_schema_member = __esm({
       defaultValue: nullable(schemaDefaultValueSchema),
       overrideOf: nullableId,
       system: nullable(schemaSystemMetadataSchema),
-      storage: nullable(picklist(["immutable", "save", "session", "writable"])),
+      storage: nullable(
+        picklist(["immutable", "save", "session", "writable", "user"])
+      ),
       distribution: nullable(picklist(["sparse", "packed"])),
       storageKey: nullableId
     };
@@ -52346,7 +52917,8 @@ var init_codecs = __esm({
       "immutable",
       "save",
       "session",
-      "writable"
+      "writable",
+      "user"
     ];
     MEMBER_DISTRIBUTION = ["sparse", "packed"];
     STRING_FORMAT = ["localized", "plain"];
@@ -53148,7 +53720,8 @@ var init_class = __esm({
       "immutable",
       "save",
       "session",
-      "writable"
+      "writable",
+      "user"
     ];
     CLASS_SCHEMA_RECORD_ADAPTER = {
       recordKind: "class",
@@ -55204,7 +55777,11 @@ function booleanAt(value, path) {
 }
 function nullableStorage(value, path) {
   if (value === null) return;
-  stringIn(value, /* @__PURE__ */ new Set(["immutable", "save", "session", "writable"]), path);
+  stringIn(
+    value,
+    /* @__PURE__ */ new Set(["immutable", "save", "session", "writable", "user"]),
+    path
+  );
 }
 function stringIn(value, allowed, path) {
   const result = stringAt(value, path);
@@ -55587,16 +56164,8 @@ function quoteNeoString(value) {
   return JSON.stringify(value);
 }
 function indentNeoSource(value, spaces) {
-  return indentLines(value, spaces, true);
-}
-function indentNeoSourceNonEmptyLines(value, spaces) {
-  return indentLines(value, spaces, false);
-}
-function indentLines(value, spaces, indentEmptyLines) {
   const prefix = " ".repeat(spaces);
-  return value.split("\n").map(
-    (line) => indentEmptyLines || line.length > 0 ? `${prefix}${line}` : line
-  ).join("\n");
+  return value.split("\n").map((line) => line.length > 0 ? `${prefix}${line}` : line).join("\n");
 }
 function formatNeoNumber(value) {
   if (!Number.isFinite(value)) {
@@ -56553,12 +57122,12 @@ ${schemaClass2.genericParameters.map((parameter4) => {
   const rendered = memberIds.map((memberId) => {
     const member = required(context.members, memberId, "member");
     const alternateIndex = context.formAlternates.length;
-    const source = indentNeoSourceNonEmptyLines(emitMember(context, member, schemaClass2.id), 2);
+    const source = indentNeoSource(emitMember(context, member, schemaClass2.id), 2);
     for (let at3 = alternateIndex; at3 < context.formAlternates.length; at3++) {
       const alternate = context.formAlternates[at3];
       context.formAlternates[at3] = {
-        shorthand: indentNeoSourceNonEmptyLines(alternate.shorthand, 2),
-        block: indentNeoSourceNonEmptyLines(alternate.block, 2)
+        shorthand: indentNeoSource(alternate.shorthand, 2),
+        block: indentNeoSource(alternate.block, 2)
       };
     }
     return { member, source };
@@ -56567,7 +57136,7 @@ ${schemaClass2.genericParameters.map((parameter4) => {
   const sources2 = rendered.map((entry) => entry.source);
   for (const memberId of memberIds)
     for (const statement of listenerStatementsByMember?.get(memberId) ?? [])
-      sources2.push(indentNeoSourceNonEmptyLines(statement, 2));
+      sources2.push(indentNeoSource(statement, 2));
   const spliced = [
     ...constructorIds.map(
       (constructorId) => emitConstructor(
@@ -56591,7 +57160,7 @@ ${sources2.join("\n\n")}
   );
   const members = [
     ...sources2.slice(0, lastValueMemberIndex + 1),
-    ...spliced.map((source) => indentNeoSourceNonEmptyLines(source, 2)),
+    ...spliced.map((source) => indentNeoSource(source, 2)),
     ...sources2.slice(lastValueMemberIndex + 1)
   ];
   return `${emitDocsText(schemaClass2.docsText)}${annotations.join("\n")}
@@ -56679,7 +57248,7 @@ function renderParameterDefault(context, argument2) {
 function emitInitBlock(code) {
   if (code.trim().length === 0) return "init {\n}";
   return `init {
-${indentNeoSourceNonEmptyLines(code.trim(), 2)}
+${indentNeoSource(code.trim(), 2)}
 }`;
 }
 function isCallableMember(member) {
@@ -56695,7 +57264,7 @@ function emitConstructor(context, schemaClass2, declared) {
   : base(${declared.baseArguments.map((argument2) => `${argument2.name}: ${argument2.code}`).join(", ")})`;
   const code = declared.code ?? "";
   const body = code.trim().length === 0 ? "{\n}" : `{
-${indentNeoSourceNonEmptyLines(code.trim(), 2)}
+${indentNeoSource(code.trim(), 2)}
 }`;
   const signature = `public ${schemaClass2.name}(${parameters})`;
   return `${annotations.join("\n")}
@@ -56740,10 +57309,10 @@ ${expression}`;
         );
       }
       return `  ${property2}:
-${indentNeoSourceNonEmptyLines(render(ordered[0]), 4)}`;
+${indentNeoSource(render(ordered[0]), 4)}`;
     }
     return `  ${property2}: [
-${ordered.map((relation) => `${indentNeoSourceNonEmptyLines(render(relation), 4)},`).join("\n\n")}
+${ordered.map((relation) => `${indentNeoSource(render(relation), 4)},`).join("\n\n")}
   ]`;
   });
   return [`@relations(
@@ -56765,7 +57334,7 @@ function emitInterface(context, value) {
   const system = value.system ? `${systemAnnotation2(value.system)}
 ` : "";
   return `${emitDocsText(value.docsText)}${id(value.id)}${system}interface ${value.name}${bases.length ? ` : ${bases.join(", ")}` : ""} {
-${members.map((member) => indentNeoSourceNonEmptyLines(member, 2)).join("\n\n")}
+${members.map((member) => indentNeoSource(member, 2)).join("\n\n")}
 }
 `;
 }
@@ -56774,7 +57343,7 @@ function emitEnum(value) {
     (option) => `${emitDocsText(option.docsText)}${id(option.id)}${option.name}${option.text === option.name ? "" : ` = ${quote(option.text)}`},`
   );
   return `${emitDocsText(value.docsText)}${id(value.id)}enum ${value.name} {
-${options.map((option) => indentNeoSourceNonEmptyLines(option, 2)).join("\n")}
+${options.map((option) => indentNeoSource(option, 2)).join("\n")}
 }
 `;
 }
@@ -56807,11 +57376,11 @@ ${prefix}${renderType(context, member.returnType, enclosingClassId)} ${member.na
     const setterBlock = setter ? `
 
   set {
-${indentNeoSourceNonEmptyLines(setter, 4)}
+${indentNeoSource(setter, 4)}
   }` : "";
     const block = `${head} {
   get {
-${indentNeoSourceNonEmptyLines(getter, 4)}
+${indentNeoSource(getter, 4)}
   }${setterBlock}
 }`;
     const expression = expressionBodyExpression(getter);
@@ -57791,7 +58360,7 @@ function emitFunctionBody(sourceText) {
   const code = sourceText.trim();
   if (code.length === 0) return "{\n}";
   return `{
-${indentNeoSourceNonEmptyLines(code, 2)}
+${indentNeoSource(code, 2)}
 }`;
 }
 function id(value) {
@@ -57910,7 +58479,7 @@ function emitVariant(context, className, variant2, folder, variantInitializers)
   const type = folder?.binding == null ? `NeoVariant<${className}>` : `${NEO_LOOKUP_VARIANT_TYPE_NAME}<${className}, ${renderLookupEntryType(context, folder.binding.collectionMemberId)}>`;
   return `${annotations.join("\n")}
 ${type} ${variant2.name} =
-${indentNeoSourceNonEmptyLines(initializer, 2)};`;
+${indentNeoSource(initializer, 2)};`;
 }
 function variantFolderSymbol(folder) {
   if (folder.path.length === 0) return "Root";
@@ -62084,7 +62653,7 @@ function numberArgument(value, name) {
 }
 function storageValue(value, name) {
   const enumValue2 = contextualEnumArgument(value, name)?.toLowerCase();
-  return enumValue2 === "immutable" || enumValue2 === "save" || enumValue2 === "session" || enumValue2 === "writable" ? enumValue2 : null;
+  return enumValue2 === "immutable" || enumValue2 === "save" || enumValue2 === "session" || enumValue2 === "writable" || enumValue2 === "user" ? enumValue2 : null;
 }
 function assertWritableStorageRules(context, ownerClass, declaration, inheritedId) {
   const site = `${ownerClass.name}.${declaration.name}`;
@@ -65801,7 +66370,8 @@ var init_dialogue_sources = __esm({
           for (const [field, expression] of [
             ["rootAssetsMemberId", "root.Assets"],
             ["rootSaveFileMemberId", "root.Save"],
-            ["rootSessionMemberId", "root.Session"]
+            ["rootSessionMemberId", "root.Session"],
+            ["rootUserMemberId", "root.User"]
           ]) {
             const memberId = optionalString2(project[field]);
             const member = memberId ? this.members.get(memberId) : void 0;
@@ -66937,7 +67507,7 @@ function projectSchemaManifest(input, options = {}) {
       genericOwnerClassIds.set(parameterId, classId);
     }
   }
-  const rootMemberIds2 = options.rootMemberIds ?? inferRootMemberIds(members);
+  const rootMemberIds = options.rootMemberIds ?? inferRootMemberIds(members);
   const environment = {
     sourceUri: options.sourceUri ?? defaultSourceUri,
     members: memberById2,
@@ -66954,7 +67524,7 @@ function projectSchemaManifest(input, options = {}) {
     effectiveWritabilityByMemberId: effectiveMemberWritability(
       members,
       classes,
-      rootMemberIds2
+      rootMemberIds
     )
   };
   const declaredTypes = [
@@ -66968,7 +67538,7 @@ function projectSchemaManifest(input, options = {}) {
       (item, index) => enumType(item, environment, `enums[${index}]`)
     )
   ];
-  const rootType = createRootType(rootMemberIds2, environment);
+  const rootType = createRootType(rootMemberIds, environment);
   declaredTypes.push(rootType);
   const roots = options.roots ?? [
     {
@@ -67107,10 +67677,10 @@ function resolvedAllowedStorage(classId, environment) {
   return null;
 }
 function constraintDefaultWritability(allowed) {
-  return allowed === "immutable" || allowed === "save" || allowed === "session" ? allowed : "session";
+  return allowed === "immutable" || allowed === "save" || allowed === "session" || allowed === "user" ? allowed : "session";
 }
 function declaredStorageWritability(storage, staticOwnerClassId, environment) {
-  if (storage === "immutable" || storage === "save" || storage === "session") {
+  if (storage === "immutable" || storage === "save" || storage === "session" || storage === "user") {
     return storage;
   }
   if (storage === "writable") return "runtime";
@@ -67124,12 +67694,13 @@ function staticDefaultWritability(classId, environment) {
 }
 function createRootType(ids, environment) {
   const definitions = [
-    ["Assets", ids.assets, false],
-    ["Save", ids.save, true],
-    ["Session", ids.session, true]
+    ["Assets", ids.assets, false, "immutable"],
+    ["Save", ids.save, true, "save"],
+    ["Session", ids.session, true, "session"],
+    ["User", ids.user, true, "user"]
   ];
   const members = [];
-  for (const [name, memberId, writable] of definitions) {
+  for (const [name, memberId, writable, writability] of definitions) {
     if (!memberId) continue;
     const member = environment.members.get(memberId);
     if (!member) continue;
@@ -67139,7 +67710,7 @@ function createRootType(ids, environment) {
       kind: "property",
       type: memberType(member, environment, /* @__PURE__ */ new Set(), `root.${name}`),
       writable,
-      writability: name === "Assets" ? "immutable" : name === "Session" ? "session" : "save",
+      writability,
       documentation: `Project ${name.toLowerCase()} root (${memberId}).`,
       ...sourceLocation(member.source, environment, `root.${name}.source`)
     });
@@ -67162,7 +67733,8 @@ function inferRootMemberIds(members) {
   return {
     assets: unique("immutable"),
     save: unique("save"),
-    session: unique("session")
+    session: unique("session"),
+    user: unique("user")
   };
 }
 function effectiveMemberWritability(members, classes, roots) {
@@ -67183,7 +67755,7 @@ function effectiveMemberWritability(members, classes, roots) {
     seen.add(memberId);
     const member = memberById2.get(memberId);
     if (!member) return null;
-    if (member.storage === "immutable" || member.storage === "save" || member.storage === "session" || member.storage === "writable") {
+    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;
@@ -67251,6 +67823,7 @@ function effectiveMemberWritability(members, classes, roots) {
   if (typeof roots.session === "string") {
     rootStorage.set(roots.session, "session");
   }
+  if (typeof roots.user === "string") rootStorage.set(roots.user, "user");
   for (const [memberId, member] of memberById2) {
     const declared = rootStorage.get(memberId) ?? declaredStorage(memberId);
     if (declared === "writable") {
@@ -67322,6 +67895,7 @@ function schemaClass(value, environment, field) {
     ),
     ...value.declarationModifier === "abstract" ? { abstract: true } : {},
     ...value.declarationModifier === "sealed" ? { sealed: true } : {},
+    ...resolvedAllowedStorage(id2, environment) === "user" ? { userClass: true } : {},
     ...sourceLocation(value.source, environment, `${field}.source`),
     typeParameters: records(
       value.genericParameters ?? [],
@@ -68817,62 +69391,6 @@ var init_variant_member = __esm({
   }
 });
 
-// ../src/models/project/project-root-members.ts
-function buildRootStorageMap(project) {
-  const map = /* @__PURE__ */ new Map();
-  for (const root of PROJECT_ROOTS) {
-    map.set(project[root.projectField], root.storage);
-  }
-  return map;
-}
-function writtenRootStorage(project, memberIds) {
-  const map = /* @__PURE__ */ new Map();
-  for (const root of PROJECT_ROOTS) {
-    const memberId = project[root.projectField];
-    if (memberIds.has(memberId)) map.set(memberId, root.storage);
-  }
-  return map;
-}
-function isProjectRootMember(project, memberId) {
-  return PROJECT_ROOTS.some((root) => project[root.projectField] === memberId);
-}
-function projectRootMembersInDisplayOrder(project) {
-  return PROJECT_ROOTS.map((root) => ({
-    root,
-    memberId: project[root.projectField]
-  }));
-}
-var PROJECT_ROOTS;
-var init_project_root_members = __esm({
-  "../src/models/project/project-root-members.ts"() {
-    "use strict";
-    init_member_storage();
-    PROJECT_ROOTS = [
-      {
-        key: "Assets",
-        choice: "assets",
-        projectField: "rootAssetsMemberId",
-        label: "Assets",
-        storage: 1 /* Immutable */
-      },
-      {
-        key: "Save",
-        choice: "save",
-        projectField: "rootSaveFileMemberId",
-        label: "Save",
-        storage: 2 /* Save */
-      },
-      {
-        key: "Session",
-        choice: "session",
-        projectField: "rootSessionMemberId",
-        label: "Session",
-        storage: 3 /* Session */
-      }
-    ];
-  }
-});
-
 // ../src/runtime/neoscript/analyzer-types.ts
 function createAnalyzerSchemaIndex(context) {
   return projectSchemaIndexFor({
@@ -69181,6 +69699,7 @@ function classToLanguageType(schemaClass2, context) {
     ...schemaClass2.docsText ? { documentation: schemaClass2.docsText } : {},
     kind: "class",
     abstract: isAbstractClass(schemaClass2),
+    ...resolveAllowedStorage(schemaClass2.id, context.vm.classes) === 5 /* User */ ? { userClass: true } : {},
     location: virtualIdentifierLocation(
       context,
       "Classes",
@@ -69455,6 +69974,8 @@ function symbolWritability(memberId, context, staticOwnerClassId) {
       return { writability: "session" };
     case 4 /* Writable */:
       return { writability: "runtime" };
+    case 5 /* User */:
+      return { writability: "user" };
   }
 }
 function uniqueEffectiveWritability(memberId, context) {
@@ -69476,6 +69997,8 @@ function uniqueEffectiveWritability(memberId, context) {
       return "save";
     case 3 /* Session */:
       return "session";
+    case 5 /* User */:
+      return "user";
   }
 }
 function interfaceToLanguageType(neoInterface, context) {
@@ -69576,13 +70099,10 @@ function interfaceMemberToSymbol(neoInterface, key, member, context, inherited)
   };
 }
 function createRootType2(context) {
-  const definitions = [
-    ["Assets", context.vm.project.rootAssetsMemberId],
-    ["Save", context.vm.project.rootSaveFileMemberId],
-    ["Session", context.vm.project.rootSessionMemberId]
-  ];
   const members = [];
-  for (const [index, [name, memberId]] of definitions.entries()) {
+  for (const [index, root] of PROJECT_ROOTS.entries()) {
+    const name = root.key;
+    const memberId = context.vm.project[root.projectField];
     const member = analyzerMemberById(context, memberId);
     if (!member) continue;
     members.push({
@@ -69590,8 +70110,8 @@ function createRootType2(context) {
       name,
       kind: "property",
       type: memberRuntimeType(member, context),
-      writable: name !== "Assets",
-      writability: name === "Assets" ? "immutable" : name === "Session" ? "session" : "save",
+      writable: root.storage !== 1 /* Immutable */,
+      writability: ROOT_WRITABILITY[root.storage],
       documentation: `Project ${name.toLowerCase()} root (${memberId}).`,
       location: virtualIdentifierLocation(
         context,
@@ -70158,9 +70678,7 @@ function projectLanguageVersion(context) {
     `adapter:${NEOSCRIPT_COMPILER_ADAPTER_REVISION}`,
     context.vm.project.id,
     context.vm.project.updatedAt,
-    context.vm.project.rootAssetsMemberId,
-    context.vm.project.rootSaveFileMemberId,
-    context.vm.project.rootSessionMemberId,
+    ...projectRootMemberIds(context.vm.project),
     ...records2.map((record7) => `${record7.id}:${record7.updatedAt}`).sort()
   ].join("|");
 }
@@ -70344,7 +70862,7 @@ function virtualEnumOptionLine(optionName, optionId = optionName) {
 function virtualRootMemberLine(name, memberId) {
   return `    public object ${virtualCSharpIdentifier(name)} { get; } // Neo root member ${memberId}`;
 }
-var NEOSCRIPT_COMPILER_ADAPTER_REVISION, UNKNOWN_TYPE2, storageResolverByContext, CANONICAL_MEMBER_IDS;
+var NEOSCRIPT_COMPILER_ADAPTER_REVISION, UNKNOWN_TYPE2, storageResolverByContext, CANONICAL_MEMBER_IDS, ROOT_WRITABILITY;
 var init_neoscript_language_context_adapter = __esm({
   "../src/runtime/neoscript/neoscript-language-context-adapter.ts"() {
     "use strict";
@@ -70370,6 +70888,12 @@ var init_neoscript_language_context_adapter = __esm({
     };
     storageResolverByContext = /* @__PURE__ */ new WeakMap();
     CANONICAL_MEMBER_IDS = /* @__PURE__ */ new WeakMap();
+    ROOT_WRITABILITY = {
+      [1 /* Immutable */]: "immutable",
+      [2 /* Save */]: "save",
+      [3 /* Session */]: "session",
+      [5 /* User */]: "user"
+    };
   }
 });
 
@@ -75858,6 +76382,15 @@ function readNeoScriptRuntimeRow(ctx, valueId) {
     ctx.__valueOverlay
   );
 }
+function inspectNeoScriptValueReference(ctx, value, collection, index) {
+  let id2 = findKnownRowIdByValueReference(value, ctx);
+  if (id2 === null && collection !== void 0 && index !== void 0 && typeof value === "string" && (findKnownRowIdByValueReference(collection, ctx) !== null || Array.isArray(collection) && typeof index === "number" && ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(collection)?.has(index) || typeof collection === "object" && collection !== null && typeof index === "string" && ctx.__unorderedListProjections?.referenceEntryKeysByRecord.get(collection)?.has(index))) {
+    id2 = value;
+  }
+  if (id2 === null) return null;
+  const row = readNeoScriptRuntimeRow(ctx, id2);
+  return row === null ? null : { row, member: memberForValueRow(row, ctx) };
+}
 function withEvaluationRuntime(ctx, writes) {
   if (ctx.__runtimeSessionValues !== void 0 && ctx.__executionState !== void 0 && ctx.__valueOverlay !== void 0) {
     ctx.__unorderedListProjections ??= createUnorderedListProjectionCache();
@@ -78228,6 +78761,11 @@ function effectiveStaticStorage(memberId, ctx) {
       `Static member '${memberId}' did not resolve to exactly one effective storage class.`
     );
   }
+  if (storage === 5 /* User */) {
+    throw new NSGetterRuntimeError(
+      `Static member '${memberId}' belongs to a User class. User classes can't declare static stored members.`
+    );
+  }
   return storage;
 }
 function staticBindingTargetId(member, ctx) {
@@ -78980,6 +79518,10 @@ function listenerReceiverOnOwner(memberId, ownerReceiver, ctx) {
   return ownerReceiver;
 }
 function invokeActionListeners(listeners, args, ctx, frame, ownerReceiver, callSiteId) {
+  if (ctx.assertActionInvocable !== void 0) {
+    const ownerRowId = findKnownRowIdByValueReference(ownerReceiver, ctx);
+    if (ownerRowId !== null) ctx.assertActionInvocable(ownerRowId);
+  }
   for (let index = 0; index < listeners.length; index += 1) {
     try {
       invokeDelegateValue(
@@ -80644,17 +81186,9 @@ function classIdForValueRow(row, ctx) {
 function rootMemberForValueRow(row, ctx) {
   if (typeof ctx.rootValue !== "object" || ctx.rootValue === null) return null;
   const rootRecord = ctx.rootValue;
-  const project = ctx.vm.project;
-  if (rootRecord.Assets === row.value) {
-    return evalMemberById(ctx.vm, project.rootAssetsMemberId);
-  }
-  if (rootRecord.Save === row.value) {
-    return evalMemberById(ctx.vm, project.rootSaveFileMemberId);
-  }
-  if (rootRecord.Session === row.value) {
-    return evalMemberById(ctx.vm, project.rootSessionMemberId);
-  }
-  return null;
+  const root = PROJECT_ROOTS.find((root2) => rootRecord[root2.key] === row.value);
+  if (root === void 0) return null;
+  return evalMemberById(ctx.vm, ctx.vm.project[root.projectField]);
 }
 function memberForCustomSchemaValue(classId, schemaKey, ctx) {
   const memberId = cachedMergedSchemaMemberId(classId, schemaKey, ctx);
@@ -91122,7 +91656,7 @@ function collectVariantGraphValueIds(args) {
     args.variants.filter((variant2) => args.variantIds.has(variant2.id))
   );
   if (roots.length === 0) return collected;
-  const rootMemberIds2 = new Set(roots.map((root) => root.member.id));
+  const rootMemberIds = new Set(roots.map((root) => root.member.id));
   const rootOwners = /* @__PURE__ */ new Map();
   resolveSemanticOwnerMembersForValues(
     document,
@@ -91131,7 +91665,7 @@ function collectVariantGraphValueIds(args) {
     rootOwners
   );
   for (const [valueId, rootOwner] of rootOwners) {
-    if (!rootMemberIds2.has(rootOwner.id)) continue;
+    if (!rootMemberIds.has(rootOwner.id)) continue;
     collected.add(valueId);
   }
   return collected;
@@ -93096,7 +93630,7 @@ var init_project_read_base = __esm({
 // ../src/models/project/project-types.ts
 function isProject(value) {
   const v = value;
-  return typeof v?.name === "string" && typeof v?.id === "string" && isProjectOwner(v.owner) && isActorIdentifier(v.author) && typeof v?.createdAt === "number" && typeof v?.updatedAt === "number" && typeof v?.rootAssetsMemberId === "string" && typeof v?.rootSaveFileMemberId === "string" && typeof v?.rootSessionMemberId === "string" && isOptionalNullableString4(v.defaultPriorityGroupId) && isOptionalNullableString4(v.defaultTextureTemplateId) && isOptionalNullableString4(v.defaultAudioClipTemplateId) && isProjectExportSettingsOrEmpty(v.exportSettings);
+  return typeof v?.name === "string" && typeof v?.id === "string" && isProjectOwner(v.owner) && isActorIdentifier(v.author) && typeof v?.createdAt === "number" && typeof v?.updatedAt === "number" && typeof v?.rootAssetsMemberId === "string" && typeof v?.rootSaveFileMemberId === "string" && typeof v?.rootSessionMemberId === "string" && typeof v?.rootUserMemberId === "string" && isOptionalNullableString4(v.defaultPriorityGroupId) && isOptionalNullableString4(v.defaultTextureTemplateId) && isOptionalNullableString4(v.defaultAudioClipTemplateId) && isProjectExportSettingsOrEmpty(v.exportSettings);
 }
 function isProjectOwner(value) {
   if (!isActorIdentifier(value)) return false;
@@ -97471,10 +98005,10 @@ function commitPreparationAnimationSchema(document) {
       current = typeof current.extendsClassId === "string" ? classesById.get(current.extendsClassId) : void 0;
     }
   }
-  const rootMemberIds2 = /* @__PURE__ */ new Set();
+  const rootMemberIds = /* @__PURE__ */ new Set();
   for (const member of document.members) {
     if (isMemberClass(member) && rootKindByClassId.has(member.classId)) {
-      rootMemberIds2.add(member.id);
+      rootMemberIds.add(member.id);
     }
   }
   const segmentClassIds = /* @__PURE__ */ new Set();
@@ -97483,7 +98017,7 @@ function commitPreparationAnimationSchema(document) {
       segmentClassIds.add(classId);
     }
   }
-  return { rootMemberIds: rootMemberIds2, segmentClassIds };
+  return { rootMemberIds, segmentClassIds };
 }
 function isAnimationSegmentValueRow(data, schema) {
   if (data === null || typeof data !== "object") return false;
@@ -104875,7 +105409,8 @@ function neoScriptCompilationProjectContract(document) {
       id: document.project.id,
       rootAssetsMemberId: document.project.rootAssetsMemberId,
       rootSaveFileMemberId: document.project.rootSaveFileMemberId,
-      rootSessionMemberId: document.project.rootSessionMemberId
+      rootSessionMemberId: document.project.rootSessionMemberId,
+      rootUserMemberId: document.project.rootUserMemberId
     },
     projectFiles: (document.projectFiles ?? []).map((file) => ({
       id: file.id,
@@ -107005,9 +107540,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
   const accessModifierErrors = validateDocumentAccessModifiers({
     members: postDocument.members,
     classes: postDocument.classes,
-    rootMemberIds: new Set(
-      PROJECT_ROOTS.map((root) => postDocument.project[root.projectField])
-    ),
+    rootMemberIds: new Set(projectRootMemberIds(postDocument.project)),
     dialogues: postDocument.dialogues,
     dialogueGroups: postDocument.dialogueGroups
   });
@@ -107297,11 +107830,9 @@ function attachPreparedValuePlacements(prepared, document) {
     }
   }
   const placements = projectValueHeadPlacementGraph({
-    rootMembers: [
-      { id: document.project.rootAssetsMemberId, label: "Assets" },
-      { id: document.project.rootSaveFileMemberId, label: "Save" },
-      { id: document.project.rootSessionMemberId, label: "Session" }
-    ],
+    rootMembers: projectRootMembersInDisplayOrder(document.project).map(
+      ({ root, memberId }) => ({ id: memberId, label: root.label })
+    ),
     variantRoots: (document.variants ?? []).map((variant2) => ({
       variantId: variant2.id,
       valueId: variant2.valueId
@@ -110653,6 +111184,7 @@ var init_project_version_schema_commit = __esm({
     init_stored_value_shape();
     init_project2();
     init_internal_record_relations();
+    init_project_root_members();
     init_world_content_sidecar_validation();
     init_variants();
     init_effective_value_reader();
@@ -111127,6 +111659,129 @@ var init_project_member_change_listener_validation = __esm({
   }
 });
 
+// ../src/database/user-delegate-target-validation.ts
+function assertStagedUserDelegateTargetsValid(projected, changes) {
+  if (!changes.some((change) => TRIGGER_RECORD_KINDS.has(change.recordKind))) {
+    return;
+  }
+  const userRootId = projected.project.rootUserMemberId;
+  const changedRowIds = changes.some((change) => change.recordKind !== "value") ? null : new Set(changes.map((change) => change.recordId));
+  const sources2 = authoredDelegateSources(projected, changedRowIds);
+  if (sources2.length === 0) return;
+  const resolver = new EffectiveStorageResolver({
+    members: projected.members,
+    classes: projected.classes,
+    rootStorage: buildRootStorageMap(projected.project)
+  });
+  const userClasses = resolver.userClassIds();
+  const schemaIndex = projectSchemaIndexFor(projected);
+  const isUserMember = (memberId) => {
+    const declaring = schemaIndex.declaringClassIds(memberId);
+    if (declaring.size === 0) return false;
+    for (const classId of declaring) {
+      if (!userClasses.has(classId)) return false;
+    }
+    return true;
+  };
+  const durableValueIds = /* @__PURE__ */ new Set();
+  for (const source of sources2) {
+    const storages = resolver.effectiveStorages(source.ownerMemberId);
+    if (storages.has(5 /* User */)) {
+      for (const target of source.targets) {
+        if (isUserMember(target.memberId)) continue;
+        const member = resolver.member(target.memberId);
+        const label = member === void 0 ? target.memberId : resolver.placementLabel(member);
+        throw new Error(
+          `Delegates in User data must target User members. \`${label}\` isn't one.`
+        );
+      }
+    }
+    if (!storages.has(2 /* Save */) && !storages.has(1 /* Immutable */)) {
+      continue;
+    }
+    for (const target of source.targets) {
+      if (target.valueId !== null) durableValueIds.add(target.valueId);
+    }
+  }
+  if (durableValueIds.size === 0) return;
+  const rootOwners = /* @__PURE__ */ new Map();
+  resolveSemanticOwnerMembersForValues(
+    projected,
+    durableValueIds,
+    void 0,
+    rootOwners
+  );
+  for (const valueId of durableValueIds) {
+    if (memberIdOf2(rootOwners.get(valueId)) !== userRootId) continue;
+    throw new Error(
+      `Save data can't hold a reference to \`root.User\` data. Row "${valueId}" is under \`root.User\`.`
+    );
+  }
+}
+function authoredDelegateSources(projected, changedRowIds) {
+  const sources2 = [];
+  for (const member of changedRowIds === null ? projected.members : []) {
+    if (member.kind !== 26 /* NSAction */ && member.kind !== 25 /* NSDelegate */) {
+      continue;
+    }
+    const defaultValue = member.defaultValue;
+    if (defaultValue == null || !isLiteralValueContent(defaultValue)) continue;
+    const targets = delegateTargets(defaultValue.value);
+    if (targets.length > 0) {
+      sources2.push({ ownerMemberId: member.id, targets });
+    }
+  }
+  const rowTargets = /* @__PURE__ */ new Map();
+  for (const row of projected.values) {
+    if (changedRowIds !== null && !changedRowIds.has(row.id)) continue;
+    const targets = delegateTargets(row.value);
+    if (targets.length > 0) rowTargets.set(row.id, targets);
+  }
+  if (rowTargets.size === 0) return sources2;
+  const owners = resolveSemanticOwnerMembersForValues(
+    projected,
+    new Set(rowTargets.keys())
+  );
+  for (const [rowId, owner] of owners) {
+    if (owner.kind !== 26 /* NSAction */ && owner.kind !== 25 /* NSDelegate */) {
+      continue;
+    }
+    const ownerMemberId = memberIdOf2(owner);
+    const targets = rowTargets.get(rowId);
+    if (ownerMemberId === null || targets === void 0) continue;
+    sources2.push({ ownerMemberId, targets });
+  }
+  return sources2;
+}
+function delegateTargets(body) {
+  if (isMemberDelegateTarget(body)) return [body];
+  if (!isPlainRecord3(body) || !Array.isArray(body.listeners)) return [];
+  return body.listeners.filter(isMemberDelegateTarget);
+}
+function memberIdOf2(member) {
+  if (member === void 0) return null;
+  const id2 = Reflect.get(member, "id");
+  return typeof id2 === "string" ? id2 : null;
+}
+var TRIGGER_RECORD_KINDS;
+var init_user_delegate_target_validation = __esm({
+  "../src/database/user-delegate-target-validation.ts"() {
+    "use strict";
+    init_member_kinds();
+    init_member_storage();
+    init_effective_storage();
+    init_project_root_members();
+    init_project_schema_index();
+    init_constructor_argument_ownership();
+    init_project_version_relation_sweep_trigger();
+    TRIGGER_RECORD_KINDS = /* @__PURE__ */ new Set([
+      "member",
+      "class",
+      "value"
+    ]);
+  }
+});
+
 // ../src/models/exports/unity-static-members.ts
 function requiresUnitySingleton(member) {
   return isStaticMember(member) === true && !nativePatternMembers.has(member.id);
@@ -111179,6 +111834,7 @@ function animationTrackStorage(memberIdsRootToLeaf, membersById, childrenPrefix
     if (memberId === void 0) continue;
     const storage = declaredMemberStorageFromIndex(memberId, membersById);
     if (storage === 0 /* Inherit */) continue;
+    if (storage === 5 /* User */) return null;
     return storage === 1 /* Immutable */ ? null : storage;
   }
   return null;
@@ -113171,36 +113827,36 @@ function readInterface(value) {
         `Interface "${value.id}" repeats member id "${memberValue.id}".`
       );
     }
-    const memberLabel2 = `Interface "${value.id}" member "${memberKey}"`;
+    const memberLabel3 = `Interface "${value.id}" member "${memberKey}"`;
     assertNoRetiredFields(
       memberValue,
       ["accessModifierKind", "settable", "deferred"],
-      memberLabel2
+      memberLabel3
     );
     assertOptionalOrdinal(
       memberValue.kind,
       INTERFACE_MEMBER_KINDS,
-      `${memberLabel2} kind`
+      `${memberLabel3} kind`
     );
     if (memberValue.access != null && !isMemberAccessKind(memberValue.access)) {
-      throw new Error(`${memberLabel2} access is invalid.`);
+      throw new Error(`${memberLabel3} access is invalid.`);
     }
     assertOptionalOrdinal(
       memberValue.accessors,
       PROPERTY_ACCESSOR_KINDS,
-      `${memberLabel2} accessors`
+      `${memberLabel3} accessors`
     );
     assertOptionalOrdinal(
       memberValue.dispatch,
       FUNCTION_DISPATCH_KINDS,
-      `${memberLabel2} dispatch`
+      `${memberLabel3} dispatch`
     );
     const isProperty = memberValue.kind == null || memberValue.kind === 0 /* Property */;
     if (isProperty && memberValue.dispatch != null) {
-      throw new Error(`${memberLabel2} property cannot declare dispatch.`);
+      throw new Error(`${memberLabel3} property cannot declare dispatch.`);
     }
     if (!isProperty && memberValue.accessors != null) {
-      throw new Error(`${memberLabel2} function cannot declare accessors.`);
+      throw new Error(`${memberLabel3} function cannot declare accessors.`);
     }
     memberIds.add(memberValue.id);
   }
@@ -115918,6 +116574,10 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
     `${exportData.project.name}Neo`,
     "NeoProject"
   );
+  const userClient = {
+    className: toCSharpTypeName(`${exportData.project.name}UserNeo`, "NeoUser"),
+    rootMemberId: exportData.project.rootUserMemberId
+  };
   const enums = Object.values(exportData.enums);
   const enumNames = buildEnumNameMap(enums, diagnostics);
   const typeNames = buildNameMap(
@@ -115947,6 +116607,7 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
       enumNames,
       [
         projectClassName,
+        userClient.className,
         ...enumNames.values(),
         ...typeNames.values(),
         ...interfaceNames.values(),
@@ -115970,6 +116631,7 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
     ),
     namespace: resolveGeneratedNamespace(exportData, diagnostics),
     projectClassName,
+    userClient,
     singleton: resolveUnitySingleton(exportData),
     storageResolver: new EffectiveStorageResolver({
       members: Object.values(exportData.members),
@@ -116594,7 +117256,13 @@ function memberSavedForStorage(ctx, memberId, contextSaved, declarationClassId)
   return contextSaved;
 }
 function classAllowedStorage(ctx, classId) {
-  return resolveAllowedStorage(classId, ctx.classes);
+  return ctx.storageResolver.allowedStorage(classId);
+}
+function generatedClientFor(ctx, classId) {
+  if (classAllowedStorage(ctx, classId) === 5 /* User */) {
+    return { typeName: ctx.userClient.className, parameter: "user" };
+  }
+  return { typeName: ctx.projectClassName, parameter: "project" };
 }
 function isWritableConstraint(storage) {
   return storage === 2 /* Save */ || storage === 3 /* Session */ || storage === 4 /* Writable */;
@@ -117217,6 +117885,7 @@ function nsGetterClassReturnSaved(ctx, member) {
   const ownership = nsGetterReturnOwnership(ctx, getter, visited);
   if (ownership === "save") return true;
   if (ownership === "session") return true;
+  if (ownership === "user") return true;
   if (ownership === "asset") return false;
   return null;
 }
@@ -117502,9 +118171,8 @@ function pointerSource2(ctx, pointer, variables, visitedGetterMemberIds) {
       );
       if (pointer.keyOf.pointer.type === "variable" /* variable */ && pointer.keyOf.pointer.variableId === "__root__") {
         const key2 = stringLiteralPointerValue(pointer.keyOf.key);
-        if (key2 === "Save") return sourceForRootMember(ctx, "save");
-        if (key2 === "Session") return sourceForRootMember(ctx, "session");
-        if (key2 === "Assets") return sourceForRootMember(ctx, "asset");
+        const root = PROJECT_ROOTS.find((candidate) => candidate.key === key2);
+        if (root !== void 0) return sourceForRootMember(ctx, root);
       }
       const key = stringLiteralPointerValue(pointer.keyOf.key);
       return key === null ? unknownSource() : sourceForMemberAccess(ctx, parent, key);
@@ -117712,12 +118380,12 @@ function sourceForCallGetter(ctx, memberId, visitedGetterMemberIds) {
   };
 }
 function sourceForRootMember(ctx, root) {
-  const memberId = root === "save" ? ctx.exportData.project.rootSaveFileMemberId : root === "session" ? ctx.exportData.project.rootSessionMemberId : ctx.exportData.project.rootAssetsMemberId;
+  const memberId = ctx.exportData.project[root.projectField];
   const member = resolveMemberById(ctx, memberId, "project.rootMemberId");
   return {
     memberId,
     typeInfo: member === null ? null : memberTypeInfoForCodegen(ctx, member),
-    ownership: root
+    ownership: pointerOwnershipForStorage(root.storage)
   };
 }
 function sourceForMemberAccess(ctx, parent, key) {
@@ -117771,6 +118439,7 @@ function ownershipForMemberStorage(ctx, memberId) {
   const storages = ctx.storageResolver.effectiveStorages(memberId);
   if (storages.has(2 /* Save */)) return "save";
   if (storages.has(3 /* Session */)) return "session";
+  if (storages.has(5 /* User */)) return "user";
   if (storages.has(1 /* Immutable */)) return "asset";
   return null;
 }
@@ -117813,6 +118482,8 @@ function storageForPointerOwnership(ownership) {
       return 2 /* Save */;
     case "session":
       return 3 /* Session */;
+    case "user":
+      return 5 /* User */;
     case "asset":
       return 1 /* Immutable */;
   }
@@ -117823,6 +118494,8 @@ function pointerOwnershipForStorage(storage) {
       return "save";
     case 3 /* Session */:
       return "session";
+    case 5 /* User */:
+      return "user";
     case 1 /* Immutable */:
       return "asset";
   }
@@ -118190,9 +118863,7 @@ function collectProjectDocumentInheritanceFlagsErrors(document, phase = "complet
     phase,
     members: document.members,
     classes: document.classes,
-    rootMemberIds: new Set(
-      PROJECT_ROOTS.map((root) => document.project[root.projectField])
-    ),
+    rootMemberIds: new Set(projectRootMemberIds(document.project)),
     signatureProjector: {
       format: formatGeneratedInstanceMemberSignature,
       resolveLocal: (classId, schemaKey) => getGeneratedSignatures().projectLocal(classId, schemaKey),
@@ -118994,12 +119665,14 @@ function assertProjectVersionWholeGraphWritesValid(args) {
   assertWorldFootprintEntryTypes(projected, changes);
   assertStagedSchemaIdentifiersValid(projected, changes);
   assertStagedActionListenersValid(projected, changes);
+  assertStagedUserDelegateTargetsValid(projected, changes);
   assertAuthoredMemberChangeListenersValid(args.document, projected, changes);
   assertStagedVariantMemberValuesValid(projected, changes);
   assertStagedUnitySingletonValid(projected, changes);
   assertStagedProjectInterfaceValid(projected, changes);
   if (changesRequireInheritanceFlagsValidation(changes)) {
     assertProjectDocumentInheritanceFlagsValid(projected);
+    assertProjectDocumentStorageValid(projected);
   }
   assertStagedTileGridReferencesValid(args.document, projected, changes);
   assertStagedInternalRecordRelationsValid(args.document, projected, changes);
@@ -119018,6 +119691,14 @@ function assertProjectVersionWholeGraphWritesValid(args) {
     });
   }
 }
+function assertProjectDocumentStorageValid(projected) {
+  const errors = validateDocumentStorage({
+    members: projected.members,
+    classes: projected.classes,
+    rootStorage: buildRootStorageMap(projected.project)
+  });
+  if (errors.length > 0) throw new Error(errors[0].message);
+}
 function assertStagedUnorderedContainmentValid(current, projected, changes) {
   const currentValues = new Map(
     current.values.map((value) => [value.id, value])
@@ -119597,11 +120278,9 @@ function assertStagedSchemaIdentifiersValid(projected, changes) {
     (change) => change.operation !== "delete" && ["class", "enum", "interface", "member"].includes(change.recordKind)
   );
   if (relevant.length === 0) return;
-  const directlyAuthoredMemberIds = /* @__PURE__ */ new Set([
-    projected.project.rootAssetsMemberId,
-    projected.project.rootSaveFileMemberId,
-    projected.project.rootSessionMemberId
-  ]);
+  const directlyAuthoredMemberIds = new Set(
+    projectRootMemberIds(projected.project)
+  );
   for (const schemaClass2 of projected.classes) {
     for (const memberId of Object.values(schemaClass2.schema ?? {})) {
       directlyAuthoredMemberIds.add(memberId);
@@ -120169,7 +120848,9 @@ var KNOWN_TRANSACTION_OPERATIONS, INTERFACE_VALIDATED_RECORD_KINDS, ACTION_LISTE
 var init_project_version_whole_graph_validation = __esm({
   "../src/database/project-version-whole-graph-validation.ts"() {
     "use strict";
+    init_project_root_members();
     init_project_member_change_listener_validation();
+    init_user_delegate_target_validation();
     init_project_world_placement_bindings();
     init_unity_static_members();
     init_project_version_types();
@@ -120181,6 +120862,7 @@ var init_project_version_whole_graph_validation = __esm({
     init_projectInterfaceValidation();
     init_project_document_inheritance_validation();
     init_project_root_members();
+    init_effective_storage();
     init_project_schema_identifier_validation();
     init_packed_value_write_fold();
     init_project_version_write_changes();
@@ -120514,11 +121196,9 @@ function refreshReferencedOutsideDocument(args) {
 }
 function inMemoryScopeReader(document, records2) {
   const canonicalPlacementByValueId = projectValueHeadPlacementGraph({
-    rootMembers: [
-      { id: document.project.rootAssetsMemberId, label: "Assets" },
-      { id: document.project.rootSaveFileMemberId, label: "Save" },
-      { id: document.project.rootSessionMemberId, label: "Session" }
-    ],
+    rootMembers: projectRootMembersInDisplayOrder(document.project).map(
+      ({ root, memberId }) => ({ id: memberId, label: root.label })
+    ),
     variantRoots: (document.variants ?? []).map((variant2) => ({
       variantId: variant2.id,
       valueId: variant2.valueId
@@ -120706,6 +121386,7 @@ var init_client_commit_preparation = __esm({
     init_valueHeadPlacementGraph();
     init_build_default_member_value();
     init_packed_value_encoding();
+    init_project_root_members();
     init_commit_preparation_animation_scope();
     init_commit_preparation_scope_planner();
     init_packed_value_write_fold();
@@ -120827,12 +121508,10 @@ function sourceDiagnosticMapper(analysis) {
   };
 }
 function collectSourceSchemaErrors(document) {
-  const rootMemberIds2 = new Set(
-    PROJECT_ROOTS.map((root) => document.project[root.projectField])
-  );
+  const rootMemberIds = new Set(projectRootMemberIds(document.project));
   const errors = [];
   for (const validate3 of [
-    () => validateDocumentAccessModifiers({ ...document, rootMemberIds: rootMemberIds2 }),
+    () => validateDocumentAccessModifiers({ ...document, rootMemberIds }),
     () => collectProjectDocumentInheritanceFlagsErrors(document, "schema")
   ]) {
     try {
@@ -121113,8 +121792,10 @@ function createListenerLoweringDocument(args, active) {
     compiledConstructors.map((constructor2) => [constructor2.id, constructor2])
   );
   const rootByName = /* @__PURE__ */ new Map();
-  for (const root of PROJECT_ROOTS) {
-    const id2 = members.get(document.project[root.projectField])?.valueId;
+  for (const { root, memberId } of projectRootMembersInDisplayOrder(
+    document.project
+  )) {
+    const id2 = members.get(memberId)?.valueId;
     if (typeof id2 === "string") rootByName.set(root.key, id2);
   }
   return {
@@ -123678,29 +124359,32 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
   };
 }
 function lowerProtectedRootMembers(base, analysis) {
-  const storageNames = ["immutable", "save", "session"];
-  const candidates = storageNames.map(
-    (storage) => base.members.filter(
-      (member) => member.owner.kind === "loose" && member.storage === storage
+  const candidates = PROJECT_ROOT_SOURCE_SLOTS.map(
+    (slot) => base.members.filter(
+      (member) => member.owner.kind === "loose" && member.storage === slot.storage.toLowerCase()
     )
   );
   if (candidates.every((entries) => entries.length === 0)) return [];
-  if (candidates.some((entries) => entries.length !== 1)) {
-    throw new Error(
-      "Pulled schema does not uniquely identify the immutable/save/session project root members."
-    );
-  }
+  PROJECT_ROOT_SOURCE_SLOTS.forEach((slot, index) => {
+    if (candidates[index].length !== 1) {
+      throw new Error(
+        `Pulled schema does not uniquely identify the ${slot.name} project root member.`
+      );
+    }
+  });
   const globals = analysis.configuration.globals.filter(
     (global2) => global2.type.name === "Root"
   );
-  if (globals.length === 0) return candidates.map((entries) => entries[0]);
+  if (globals.length === 0) {
+    return candidates.map((entries) => entries[0]);
+  }
   if (globals.length !== 1 || globals[0].name !== "root") {
     throw new Error("Format-4 source requires exactly one Root root global.");
   }
   const global = globals[0];
   const slots = parseProjectRootInitializer(global.initializer);
   if (slots.length !== PROJECT_ROOT_SOURCE_SLOTS.length) {
-    throw new Error("Root must contain exactly Assets, Save, and Session.");
+    throw new Error(projectRootSlotCountError(slots));
   }
   const classes = new Map(base.classes.map((entry) => [entry.id, entry]));
   return PROJECT_ROOT_SOURCE_SLOTS.map((expected, index) => {
@@ -123763,7 +124447,7 @@ function collectInitDefaultConversions(changes, stateRecords) {
     if (!Object.prototype.hasOwnProperty.call(baseDefault, "value")) continue;
     candidates.push({
       memberId: change.recordId,
-      memberLabel: memberLabel(change.baseData, change.recordId),
+      memberLabel: memberLabel2(change.baseData, change.recordId),
       initCode,
       baseDefaultValue: baseDefault.value
     });
@@ -123893,7 +124577,7 @@ function constructedClassName(initCode) {
     return null;
   }
 }
-function memberLabel(baseData3, fallback) {
+function memberLabel2(baseData3, fallback) {
   const name = baseData3.name;
   return typeof name === "string" && name.length > 0 ? name : fallback;
 }
@@ -125796,7 +126480,8 @@ function indexValueSymbols(state, analysis) {
     const roots = [
       ["root.Assets", project.rootAssetsMemberId],
       ["root.Save", project.rootSaveFileMemberId],
-      ["root.Session", project.rootSessionMemberId]
+      ["root.Session", project.rootSessionMemberId],
+      ["root.User", project.rootUserMemberId]
     ];
     for (const [sourceName, memberId] of roots) {
       if (typeof memberId !== "string") continue;
@@ -126224,10 +126909,11 @@ function emitProjectRootSourceV4(records2, manifest, materializedConstructors, l
   );
   if (!project) return null;
   const projectData = requiredObject(project.data, "project");
-  const memberIds = rootMemberIds(projectData);
   const members = new Map(
     manifest.members.map((member) => [member.id, member])
   );
+  const rootSlots = projectRootSlots(projectData);
+  const memberIds = rootSlots.map((root) => root.memberId);
   const classes = new Map(manifest.classes.map((entry) => [entry.id, entry]));
   const values = emitStoredValueBindingSourcesV4(records2, memberIds, {
     ...options,
@@ -126240,8 +126926,7 @@ function emitProjectRootSourceV4(records2, manifest, materializedConstructors, l
       materializedConstructors.set(valueId, expression);
     }
   }
-  const declarations = PROJECT_ROOT_SOURCE_SLOTS.map((slot, index) => {
-    const memberId = memberIds[index];
+  const declarations = rootSlots.map(({ slot, memberId }) => {
     const member = members.get(memberId);
     if (!member)
       throw new Error(`Project root member ${memberId} was not pulled.`);
@@ -126294,13 +126979,13 @@ function lowerProjectRootSourceV4(state, analysis, manifest, options = {}) {
   if (validated === null) {
     return { records: [], memberValueIds: /* @__PURE__ */ new Map(), seeds: /* @__PURE__ */ new Map() };
   }
-  const { expectedIds, global, slots } = validated;
-  const bindings = PROJECT_ROOT_SOURCE_SLOTS.map((expected, index) => ({
-    memberId: expectedIds[index],
+  const { expected, global, slots } = validated;
+  const bindings = expected.map((root, index) => ({
+    memberId: root.memberId,
     purpose: "stored",
     initializer: slots[index].initializer,
     source: global.source,
-    label: `root.${expected.name}`
+    label: `root.${root.slot.name}`
   }));
   return lowerStoredValueBindingsV4(state, manifest, bindings, {
     analysis,
@@ -126313,7 +126998,7 @@ function validateProjectRootEnvelopeV4(state, analysis, parsedInitializers) {
   );
   if (!project) return null;
   const projectData = requiredObject(project.data, "project");
-  const expectedIds = rootMemberIds(projectData);
+  const expected = projectRootSlots(projectData);
   const roots = analysis.configuration.globals.filter(
     (global2) => global2.type.name === "Root"
   );
@@ -126325,15 +127010,14 @@ function validateProjectRootEnvelopeV4(state, analysis, parsedInitializers) {
     throw new Error("The protected project root global must be named root.");
   }
   const slots = parseProjectRootInitializer(global.initializer);
-  if (slots.length !== PROJECT_ROOT_SOURCE_SLOTS.length) {
-    throw new Error("Root must contain exactly Assets, Save, and Session.");
+  if (slots.length !== expected.length) {
+    throw new Error(projectRootSlotCountError(slots));
   }
-  PROJECT_ROOT_SOURCE_SLOTS.forEach((expected, index) => {
+  expected.forEach(({ slot: rootSlot, memberId }, index) => {
     const slot = slots[index];
-    const memberId = expectedIds[index];
-    if (slot.id !== memberId || slot.name !== expected.name || slot.type !== expected.type || slot.storage !== expected.storage) {
+    if (slot.id !== memberId || slot.name !== rootSlot.name || slot.type !== rootSlot.type || slot.storage !== rootSlot.storage) {
       throw new Error(
-        `Root slot ${expected.name} is protected and must retain member id ${memberId}, type/name ${expected.type} ${expected.name}, and @storage(allowed: .${expected.storage}).`
+        `Root slot ${rootSlot.name} is protected and must retain member id ${memberId}, type/name ${rootSlot.type} ${rootSlot.name}, and @storage(allowed: .${rootSlot.storage}).`
       );
     }
     const memberData = state[`member:${memberId}`]?.data;
@@ -126351,19 +127035,20 @@ function validateProjectRootEnvelopeV4(state, analysis, parsedInitializers) {
     if (authoredValueId === void 0) return;
     if (authoredValueId.kind !== "litString" || authoredValueId.value !== memberData.valueId) {
       throw new Error(
-        `Root value root.${expected.name} must retain stable value id ${memberData.valueId}.`
+        `Root value root.${rootSlot.name} must retain stable value id ${memberData.valueId}.`
       );
     }
   });
-  return { expectedIds, global, slots };
+  return { expected, global, slots };
 }
-function rootMemberIds(project) {
-  return ROOT_PROJECT_FIELDS.map((field) => {
+function projectRootSlots(project) {
+  return PROJECT_ROOT_SOURCE_SLOTS.map((slot) => {
+    const field = ROOT_PROJECT_FIELDS[slot.name];
     const id2 = project[field];
     if (typeof id2 !== "string" || id2.length === 0) {
       throw new Error(`Project record has no ${field}.`);
     }
-    return id2;
+    return { slot, memberId: id2 };
   });
 }
 function assertRootMember(member, name, storage) {
@@ -126501,14 +127186,12 @@ function rootSlotValueIds(state) {
     (record7) => record7.recordKind === "project"
   );
   if (!isObjectRecord2(project?.data)) return null;
-  const memberIds = rootMemberIds(project.data);
   const values = /* @__PURE__ */ new Map();
-  PROJECT_ROOT_SOURCE_SLOTS.forEach((slot, index) => {
-    const memberId = memberIds[index];
-    const data = memberId === void 0 ? void 0 : state[`member:${memberId}`]?.data;
+  for (const { slot, memberId } of projectRootSlots(project.data)) {
+    const data = state[`member:${memberId}`]?.data;
     if (isObjectRecord2(data) && typeof data.valueId === "string")
       values.set(slot.name, data.valueId);
-  });
+  }
   return values;
 }
 function walkRootValuePath(path, state, registry, placements, rootValues, fail2, resolveVirtualPath) {
@@ -126516,7 +127199,7 @@ function walkRootValuePath(path, state, registry, placements, rootValues, fail2,
   const slotName = segments[1];
   if (segments[0] !== "root" || slotName === void 0) {
     fail2(
-      `collectionValue path ${path} must start at a root slot (root.Assets, root.Save, or root.Session).`
+      `collectionValue path ${path} must start at a root slot (root.Assets, root.Save, root.Session, or root.User).`
     );
     return null;
   }
@@ -126525,7 +127208,7 @@ function walkRootValuePath(path, state, registry, placements, rootValues, fail2,
   );
   if (slotIndex < 0 || rootValues === null) {
     fail2(
-      `collectionValue path ${path} names root slot ${slotName ?? "<none>"}, which is not Assets, Save, or Session.`
+      `collectionValue path ${path} names root slot ${slotName ?? "<none>"}, which is not Assets, Save, Session, or User.`
     );
     return null;
   }
@@ -126637,11 +127320,12 @@ var init_root_source = __esm({
     init_value_sources();
     init_source_format();
     init_stored_value_placements();
-    ROOT_PROJECT_FIELDS = [
-      "rootAssetsMemberId",
-      "rootSaveFileMemberId",
-      "rootSessionMemberId"
-    ];
+    ROOT_PROJECT_FIELDS = {
+      Assets: "rootAssetsMemberId",
+      Save: "rootSaveFileMemberId",
+      Session: "rootSessionMemberId",
+      User: "rootUserMemberId"
+    };
     ROOT_PATH_PENDING_PREFIX = "__pending__:root-path:";
   }
 });
@@ -126724,7 +127408,8 @@ var init_root_value_paths = __esm({
     ROOT_PROJECT_FIELDS2 = [
       ["rootAssetsMemberId", "Assets"],
       ["rootSaveFileMemberId", "Save"],
-      ["rootSessionMemberId", "Session"]
+      ["rootSessionMemberId", "Session"],
+      ["rootUserMemberId", "User"]
     ];
   }
 });
@@ -131639,7 +132324,7 @@ function buildValueEmitIndexesV4(records2, manifest) {
       bindings.set(valueId, candidates);
     };
     const project = readDocument().project;
-    for (const root of PROJECT_ROOTS) add(project[root.projectField]);
+    for (const memberId of projectRootMemberIds(project)) add(memberId);
     for (const [id2, member] of members)
       if (member.modifier === 3 /* Static */) add(id2);
     let compilation;
@@ -131900,9 +132585,8 @@ function emitBindingListeners(context, member, rootId, wiring, source, defaultVa
     if (parts[0] === "root") {
       const root = PROJECT_ROOTS.find((root2) => root2.key === parts[1]);
       if (root === void 0) return false;
-      const rootMember = context.members.get(
-        context.readDocument().project[root.projectField]
-      );
+      const rootMemberId = context.readDocument().project[root.projectField];
+      const rootMember = context.members.get(rootMemberId);
       receiverClassId = typeof rootMember?.classId === "string" ? rootMember.classId : void 0;
       offset = 2;
     }
@@ -132144,7 +132828,7 @@ function emitVariantValueSourcesV4(records2, manifest, options = {}) {
       variant2.id,
       `new(
 ${authored.map(
-        ([name, expression]) => `  ${name}: ${indentNeoSourceNonEmptyLines(expression, 2).trimStart()},`
+        ([name, expression]) => `  ${name}: ${indentNeoSource(expression, 2).trimStart()},`
       ).join("\n")}
 )`
     );
@@ -138386,7 +139070,7 @@ function classValueBody(context, member, value, visited, targetTyped, outerEnvir
   }
   if (partial) {
     return fields.length === 0 ? "new { }" : `new {
-${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
+${fields.map((field) => indentNeoSource(field, 2)).join(",\n")}
 }`;
   }
   const constructor2 = storedConstruction !== null ? storedConstruction : projection.arguments.length > 0 ? constructorCallSource(
@@ -138399,7 +139083,7 @@ ${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
   if (typeof value.id === "string")
     context.materializedConstructorOverrideKeys.set(value.id, overrideKeys);
   return fields.length === 0 ? constructor2 : `${storedConstruction !== null || projection.arguments.length > 0 ? constructor2 : targetTyped ? "new()" : `new ${name}`} {
-${fields.map((field) => indentNeoSourceNonEmptyLines(field, 2)).join(",\n")}
+${fields.map((field) => indentNeoSource(field, 2)).join(",\n")}
 }`;
 }
 function emitsAsMemberDefaultDerivedAbsence(context, member, valueId) {
@@ -138681,7 +139365,7 @@ function constructorCallSource(callee, argumentsValue) {
     return inline;
   }
   return `${callee}(
-${argumentsValue.map((argument2) => `${indentNeoSourceNonEmptyLines(argument2, 2)},`).join("\n")}
+${argumentsValue.map((argument2) => `${indentNeoSource(argument2, 2)},`).join("\n")}
 )`;
 }
 function storedValueConstructor(context, schemaClass2, recordedConstructorId) {
@@ -139182,7 +139866,7 @@ function storedTypedRowSource(context, type, valueId, environment, visited, writ
       ) : [...context.values].filter(([, candidate]) => candidate.containerId === valueId).map(([id2]) => id2).sort(compareCodePoints);
       const expression = ids.length === 0 ? "[]" : `[
 ${ids.map(
-        (id2) => indentNeoSourceNonEmptyLines(
+        (id2) => indentNeoSource(
           storedTypedRowSource(
             context,
             type.entryType,
@@ -139211,7 +139895,7 @@ ${ids.map(
       const expression = entries.length === 0 ? "{}" : `{
 ${entries.flatMap(
         ([key, id2]) => typeof id2 === "string" ? [
-          indentNeoSourceNonEmptyLines(
+          indentNeoSource(
             `${emitDictionaryKey(key, keyOptions)}: ${storedTypedRowSource(
               context,
               type.entryType,
@@ -139619,7 +140303,7 @@ function listValue(context, member, value, visited, inheritedEnvironment) {
   if (ids.length === 0) return "[]";
   return `[
 ${ids.map(
-    (id2) => indentNeoSourceNonEmptyLines(
+    (id2) => indentNeoSource(
       emitValue(context, entryMember, id2, {
         environment,
         definitionSite: context.symbolsByValueId.get(id2) === void 0,
@@ -139648,7 +140332,7 @@ function dictionaryValue(context, member, value, visited, inheritedEnvironment)
   return `{
 ${entries.flatMap(
     ([key, id2]) => typeof id2 === "string" ? [
-      indentNeoSourceNonEmptyLines(
+      indentNeoSource(
         `${emitDictionaryKey(key, keyOptions)}: ${emitValue(
           context,
           entryMember,
@@ -139887,7 +140571,7 @@ function structuredLeafSource(context, kind, member, body) {
     });
     if (assignments.length === 0) return "new { }";
     return `new {
-${assignments.map((entry) => indentNeoSourceNonEmptyLines(entry, 2)).join(",\n")}
+${assignments.map((entry) => indentNeoSource(entry, 2)).join(",\n")}
 }`;
   }
   if (kind === 11 /* Sprite */) {
@@ -149783,9 +150467,9 @@ var init_service = __esm({
             position
           );
           if (!resolved) return null;
-          const memberLabel2 = resolved.symbol.kind === "member" || resolved.symbol.kind === "enumOption" || resolved.symbol.kind === "graphChild";
+          const memberLabel3 = resolved.symbol.kind === "member" || resolved.symbol.kind === "enumOption" || resolved.symbol.kind === "graphChild";
           const binding = resolved.symbol.kind === "local" || resolved.symbol.kind === "parameter" || resolved.symbol.kind === "genericParameter" || resolved.symbol.kind === "flowBinding";
-          let validNeoName = memberLabel2 ? isValidNeoProjectMemberIdentifier(newName) : binding ? isValidNeoProjectBindingIdentifier(newName) : isValidNeoProjectIdentifier(newName);
+          let validNeoName = memberLabel3 ? isValidNeoProjectMemberIdentifier(newName) : binding ? isValidNeoProjectBindingIdentifier(newName) : isValidNeoProjectIdentifier(newName);
           if (resolved.symbol.kind === "local")
             validNeoName = isValidNeoScriptBindingIdentifier(newName);
           validName = validNeoName && isGeneratedCSharpIdentifier(newName) && !isGeneratedCSharpReservedKeyword(newName);
@@ -156098,12 +156782,8 @@ function getUnityReferencedProjectFileIds(args) {
       genericEnv: EMPTY_GENERIC_ENV
     });
   }
-  const rootMemberIds2 = [
-    args.project.rootAssetsMemberId,
-    args.project.rootSaveFileMemberId,
-    args.project.rootSessionMemberId
-  ];
-  for (const rootMemberId of rootMemberIds2) {
+  const rootMemberIds = projectRootMemberIds(args.project);
+  for (const rootMemberId of rootMemberIds) {
     collectUnityReferencedProjectFileIds({
       memberId: rootMemberId,
       fileIds,
@@ -156328,6 +157008,7 @@ var EMPTY_GENERIC_ENV, NO_FILES, NO_TEXTURE_TEMPLATES, NO_CONSTRUCTORS, NO_INTER
 var init_project_unity_export_utils = __esm({
   "../src/models/exports/project-unity-export-utils.ts"() {
     "use strict";
+    init_project_root_members();
     init_neoscript_file_references();
     init_compiler();
     init_variant_value_graph();
@@ -156840,6 +157521,11 @@ function generateUnitySchemaTypes(exportData, docs = EMPTY_UNITY_CODEGEN_DOCS) {
     invokers
   );
   emit("project:client", ctx.projectClassName, client.core);
+  const userClient = emit(
+    "project:user-client",
+    ctx.userClient.className,
+    generateUserClient(ctx, ctx.userClient)
+  );
   const clientPartial = (lines) => [
     `public sealed partial class ${ctx.projectClassName}`,
     "{",
@@ -156859,6 +157545,8 @@ function generateUnitySchemaTypes(exportData, docs = EMPTY_UNITY_CODEGEN_DOCS) {
   const body = [
     ...client.contract,
     "",
+    ...userClient,
+    "",
     ...generateDialogueClasses(ctx, emit),
     ...emit(
       "dialogues:memory",
@@ -157062,7 +157750,11 @@ function generateProjectClient(ctx, projectClassName, factories, invokers) {
       "var client = await new NeoLoader().Load(synchronizer, assetDatabase, localizationOptions, null, saveOptions, cancellationToken);",
       "try",
       "{",
-      ...indent([`return new ${projectClassName}(client, dialogueOptions);`]),
+      ...indent([
+        // P104 §4.1: the user client starts before the save client's runtime.
+        `if (client.ReadsUserFile) ${ctx.userClient.className}.RequireInstance();`,
+        `return new ${projectClassName}(client, dialogueOptions);`
+      ]),
       "}",
       "catch",
       "{",
@@ -157098,6 +157790,47 @@ function generateProjectClient(ctx, projectClassName, factories, invokers) {
     )
   };
 }
+function generateUserClient(ctx, { className: userClassName, rootMemberId }) {
+  const project = ctx.projectClassName;
+  const userType = resolveRootSchemaClassInfo(
+    ctx,
+    rootMemberId,
+    "project.rootUserMemberId"
+  );
+  const userApiType = userType === null ? "NeoMemberClassWritable" : schemaClassFamilyName(ctx, userType.classId, userType.typeName, true);
+  return [
+    `public sealed partial class ${userClassName} : NeoUserClient`,
+    "{",
+    ...indent([
+      "/// <summary>The user client. Throws until NeoProjectStore.Current has loaded the user file.</summary>",
+      `public static ${userClassName} Instance => RequireLoadedClient(Create);`,
+      "",
+      `internal static ${userClassName} RequireInstance() => Instance;`,
+      "",
+      "/// <summary>",
+      "/// Completes once a current store has loaded the user file. Waits for a",
+      "/// store to start loading if none has.",
+      "/// </summary>",
+      `public static Awaitable<${userClassName}> WhenLoadedAsync(System.Threading.CancellationToken cancellationToken = default) => WhenClientLoadedAsync(Create, cancellationToken);`,
+      "",
+      `public ${userApiType} User { get; }`,
+      "",
+      `private ${userClassName}(NeoClient client)`,
+      `    : base(client, ${project}.NeoReadOnlyValueFactories, ${project}.NeoWritableValueFactories)`,
+      "{",
+      ...indent([
+        `Client.RegisterNativeFunctionInvokers(${project}.NativeFunctionInvokers);`,
+        `Client.RegisterDeferredNativeFunctionInvokers(${project}.DeferredNativeFunctionInvokers);`,
+        userType === null ? "User = client.user;" : `User = new ${userType.typeName}(client, client.user, false, NeoValueOwnership.User);`,
+        "Client.StartScriptRuntime();"
+      ]),
+      "}",
+      "",
+      `private static ${userClassName} Create(NeoClient client) => new ${userClassName}(client);`
+    ]),
+    "}"
+  ];
+}
 function scriptGridClasses(ctx) {
   return ctx.classes.filter(
     (classDef) => hasTileGridContentShape(ctx, classDef.id) && isWorldSystemKind(ctx, classDef.id, NeoWorldSystemClassKind.TileGrid)
@@ -157167,7 +157900,7 @@ function generateNativeFunctionInvokers(ctx) {
   const immediateInvokers = invokers.filter((invoker) => !invoker.deferred);
   const deferredInvokers = invokers.filter((invoker) => invoker.deferred);
   return [
-    "private static readonly IReadOnlyDictionary<string, NeoClient.NeoNativeFunctionInvoker> NativeFunctionInvokers =",
+    "internal static readonly IReadOnlyDictionary<string, NeoClient.NeoNativeFunctionInvoker> NativeFunctionInvokers =",
     "    new Dictionary<string, NeoClient.NeoNativeFunctionInvoker>",
     "    {",
     ...immediateInvokers.flatMap((invoker) => [
@@ -157178,7 +157911,7 @@ function generateNativeFunctionInvokers(ctx) {
     ]),
     "    };",
     "",
-    "private static readonly IReadOnlyDictionary<string, NeoClient.NeoDeferredNativeFunctionInvoker> DeferredNativeFunctionInvokers =",
+    "internal static readonly IReadOnlyDictionary<string, NeoClient.NeoDeferredNativeFunctionInvoker> DeferredNativeFunctionInvokers =",
     "    new Dictionary<string, NeoClient.NeoDeferredNativeFunctionInvoker>",
     "    {",
     ...deferredInvokers.flatMap((invoker) => [
@@ -161608,6 +162341,8 @@ function ownershipLiteral(storage) {
       return "NeoValueOwnership.Save";
     case 3 /* Session */:
       return "NeoValueOwnership.Session";
+    case 5 /* User */:
+      return "NeoValueOwnership.User";
   }
 }
 function getConcreteDescendants(ctx, classId) {
@@ -161704,10 +162439,11 @@ function generateSavedConstructor(ctx, classId, className, entries, genericEnv)
   const parameterText = orderedParameters.length > 0 ? `, ${orderedParameters.join(", ")}` : "";
   const argumentText = orderedParameterInfos.map((p) => p.memberName).join(", ");
   const helperArguments = argumentText.length > 0 ? `, ${argumentText}` : "";
-  const constructorParameterText = ctx.singleton ? orderedParameters.join(", ") : `${ctx.projectClassName} project${parameterText}`;
-  const helperParameterText = ctx.singleton ? orderedParameters.join(", ") : `${ctx.projectClassName} project${parameterText}`;
-  const constructorArguments4 = ctx.singleton ? argumentText : `project${helperArguments}`;
-  const clientExpression = ctx.singleton ? `${ctx.projectClassName}.RequireInstance().Client` : "project.Client";
+  const client = generatedClientFor(ctx, classId);
+  const constructorParameterText = ctx.singleton ? orderedParameters.join(", ") : `${client.typeName} ${client.parameter}${parameterText}`;
+  const helperParameterText = constructorParameterText;
+  const constructorArguments4 = ctx.singleton ? argumentText : `${client.parameter}${helperArguments}`;
+  const clientExpression = ctx.singleton ? `${client.typeName}.RequireInstance().Client` : `${client.parameter}.Client`;
   return [
     `public ${className}(${constructorParameterText})`,
     `    : this(${clientExpression}, CreateFactoryNode(${constructorArguments4}), false, NeoValueOwnership.Session)`,
@@ -161917,7 +162653,8 @@ function appendedOptionalMemberParameters(ctx, classId, declared, factoryEntries
   return appended;
 }
 function generateDeclaredConstructor(ctx, classId, className, constructorId, parameters, appendedMembers = []) {
-  const clientExpression = ctx.singleton ? `${ctx.projectClassName}.RequireInstance().Client` : "project.Client";
+  const client = generatedClientFor(ctx, classId);
+  const clientExpression = ctx.singleton ? `${client.typeName}.RequireInstance().Client` : `${client.parameter}.Client`;
   const declaredParameters = parameters.map(
     (parameter4) => parameter4.defaultLiteral === null ? `${parameter4.csharpType} ${parameter4.identifier}` : `${parameter4.csharpType} ${parameter4.identifier} = ${parameter4.defaultLiteral}`
   );
@@ -161925,7 +162662,9 @@ function generateDeclaredConstructor(ctx, classId, className, constructorId, par
     (member) => `${member.csharpType} ${member.identifier} = null`
   );
   const signatureParameters = [...declaredParameters, ...appendedParameters];
-  const parameterText = ctx.singleton ? signatureParameters.join(", ") : [`${ctx.projectClassName} project`, ...signatureParameters].join(", ");
+  const parameterText = ctx.singleton ? signatureParameters.join(", ") : [`${client.typeName} ${client.parameter}`, ...signatureParameters].join(
+    ", "
+  );
   const argumentEntries = parameters.map(
     (parameter4) => `new global::NeoCompose.Runtime.NeoDeclaredConstructorArgument("${escapeCSharpString(parameter4.declaredName)}", ${parameter4.scriptArgument})`
   ).join(", ");
@@ -161961,6 +162700,7 @@ function generateStaticMember(ctx, ownerClass, schemaKey, memberId, genericEnv)
   if (isMemberNSPropertyBase(member)) {
     return generateStaticNSProperty(
       ctx,
+      ownerClass,
       member,
       memberName,
       memberId,
@@ -162057,7 +162797,7 @@ function generateStaticFunctionMethod(ctx, ownerClass, member, genericEnv) {
   if (member.kind === 23 /* NSFunction */) {
     const invocation = callableIsDeferred(member) ? `await node.InvokeStaticAsync(new object?[] ${args})` : `node.InvokeStatic(${immediateInvocationArguments(null, scriptArguments)})`;
     const body = [
-      `var client = ${ctx.projectClassName}.RequireInstance().Client;`,
+      `var client = ${generatedClientFor(ctx, ownerClass.id).typeName}.RequireInstance().Client;`,
       `var node = NeoMemberNSFunction.GetOrCreateStatic(client, "${escapeCSharpString(member.id)}");`,
       ...isFunctionVoidTypeInfo(member.returnTypeInfo) ? [`${invocation};`] : [
         `var result = ${invocation};`,
@@ -162079,7 +162819,7 @@ function generateStaticFunctionMethod(ctx, ownerClass, member, genericEnv) {
       declaration,
       "{",
       ...indent([
-        `var client = ${ctx.projectClassName}.RequireInstance().Client;`,
+        `var client = ${generatedClientFor(ctx, ownerClass.id).typeName}.RequireInstance().Client;`,
         call2
       ]),
       "}"
@@ -162304,11 +163044,11 @@ function staticDialogueLookupGetter(ctx, member, memberId, storage, saved) {
     ]
   ];
 }
-function generateStaticNSProperty(ctx, member, memberName, memberId, genericEnv) {
+function generateStaticNSProperty(ctx, ownerClass, member, memberName, memberId, genericEnv) {
   if (!isMemberNSPropertyBase(member)) return [];
   const valueType = csharpValueType(ctx, member, true, genericEnv) ?? "object?";
   const prelude = [
-    `var client = ${ctx.projectClassName}.RequireInstance().Client;`,
+    `var client = ${generatedClientFor(ctx, ownerClass.id).typeName}.RequireInstance().Client;`,
     `var node = new NeoMemberNSProperty(client, "${escapeCSharpString(memberId)}", null, NeoValueOwnership.Session);`
   ];
   const getter = [
@@ -162614,17 +163354,18 @@ function claimVariantScopeName(ctx, used, rawName, described, path) {
   });
   return unique;
 }
-function variantResolutionExpression(ctx, targetTypeRef, variantId, lookupValueType) {
+function variantResolutionExpression(ctx, classId, targetTypeRef, variantId, lookupValueType) {
+  const client = `${generatedClientFor(ctx, classId).typeName}.RequireInstance().Client`;
   if (lookupValueType !== null) {
     return [
       `    NeoGeneratedTypesSupport.ResolveLookupVariant<${targetTypeRef}, ${lookupValueType}>(`,
-      `        ${ctx.projectClassName}.RequireInstance().Client,`,
+      `        ${client},`,
       `        "${escapeCSharpString(variantId)}");`
     ];
   }
   return [
     `    NeoGeneratedTypesSupport.ResolveVariant<${targetTypeRef}>(`,
-    `        ${ctx.projectClassName}.RequireInstance().Client,`,
+    `        ${client},`,
     `        "${escapeCSharpString(variantId)}");`
   ];
 }
@@ -162671,7 +163412,7 @@ function generateVariantScopeMembers(ctx, node, targetTypeRef, classId, isRootSc
       "/// </summary>",
       `public static NeoVariant<${targetTypeRef}> ${BASE_VARIANT_NAME} =>`,
       `    NeoGeneratedTypesSupport.ResolveBaseVariant<${targetTypeRef}>(`,
-      `        ${ctx.projectClassName}.RequireInstance().Client,`,
+      `        ${generatedClientFor(ctx, classId).typeName}.RequireInstance().Client,`,
       `        "${escapeCSharpString(classId)}");`
     );
   }
@@ -162688,6 +163429,7 @@ function generateVariantScopeMembers(ctx, node, targetTypeRef, classId, isRootSc
       `public static ${lookupValueType === null ? `NeoVariant<${targetTypeRef}>` : `NeoLookupVariant<${targetTypeRef}, ${lookupValueType}>`} ${name} =>`,
       ...variantResolutionExpression(
         ctx,
+        classId,
         targetTypeRef,
         variant2.id,
         lookupValueType
@@ -167924,7 +168666,7 @@ var UNITY_CODEGEN_REVISION;
 var init_unity_codegen_revision = __esm({
   "../src/models/exports/unity-codegen-revision.ts"() {
     "use strict";
-    UNITY_CODEGEN_REVISION = "30d96d89e3d179ccf291e522834281f90dbd44b464cf51eea76aae87eed97e7e";
+    UNITY_CODEGEN_REVISION = "45a0847addd4616acfc29f142556dcb2e0a27daae14d6aa456430228e66dbc07";
   }
 });
 
@@ -167934,7 +168676,7 @@ var init_project_unity_export_types = __esm({
   "../src/models/exports/project-unity-export-types.ts"() {
     "use strict";
     init_unity_codegen_revision();
-    PROJECT_UNITY_EXPORT_SCHEMA_VERSION = 37;
+    PROJECT_UNITY_EXPORT_SCHEMA_VERSION = 38;
   }
 });
 
@@ -177039,7 +177781,7 @@ async function runScript(workspace, command, options, dependencies = {}) {
   }
 }
 function buildStoredNeoScriptChecks(document) {
-  const checks = [];
+  const checks2 = [];
   const projectData = document;
   const dialogueEntries = document.dialogueRecords.map((dialogue) => ({
     dialogue,
@@ -177057,7 +177799,7 @@ function buildStoredNeoScriptChecks(document) {
       continue;
     }
     const nodeId = stableRecordId(node, "(unknown-node)");
-    checks.push({
+    checks2.push({
       recordKind: "dialogue-node",
       id: nodeId,
       name: nodeId,
@@ -177094,7 +177836,7 @@ function buildStoredNeoScriptChecks(document) {
         value.forEach((conditionValue, index) => {
           if (!isObjectRecord2(conditionValue)) return;
           if (conditionValue.type !== 1 /* Code */) return;
-          checks.push({
+          checks2.push({
             recordKind: "dialogue-node",
             id: nodeId,
             name: recordName,
@@ -177127,7 +177869,7 @@ function buildStoredNeoScriptChecks(document) {
         for (const [variableKey, variableValue] of Object.entries(value)) {
           if (!isObjectRecord2(variableValue)) continue;
           const variableId = typeof variableValue.id === "string" ? variableValue.id : variableKey;
-          checks.push({
+          checks2.push({
             recordKind: "dialogue-node",
             id: nodeId,
             name: recordName,
@@ -177209,7 +177951,7 @@ function buildStoredNeoScriptChecks(document) {
           const logic = isObjectRecord2(actionValue2.logic) ? actionValue2.logic : null;
           if (logic?.type !== 1 /* Code */) return;
           const actionId = stableRecordId(actionValue2, `action-${actionIndex}`);
-          checks.push({
+          checks2.push({
             recordKind: "dialogue-node",
             id: nodeId,
             name: recordName,
@@ -177260,7 +178002,7 @@ function buildStoredNeoScriptChecks(document) {
     group.conditions.forEach((conditionValue, index) => {
       if (!isObjectRecord2(conditionValue)) return;
       if (conditionValue.type !== 1 /* Code */) return;
-      checks.push({
+      checks2.push({
         recordKind: "dialogue-group",
         id: groupId,
         name: groupName,
@@ -177294,7 +178036,7 @@ function buildStoredNeoScriptChecks(document) {
   for (const migration of document.migrations) {
     const migrationId = stableRecordId(migration, "(unknown-migration)");
     const migrationName = typeof migration.name === "string" ? migration.name : migrationId;
-    checks.push({
+    checks2.push({
       recordKind: "migration",
       id: migrationId,
       name: migrationName,
@@ -177319,7 +178061,7 @@ function buildStoredNeoScriptChecks(document) {
       }
     });
   }
-  return checks;
+  return checks2;
 }
 function buildScriptDialogueContext(dialogue, nodes) {
   const trigger = nodes.find((node) => node.type === 0 /* Trigger */);
@@ -184082,6 +184824,7 @@ var init_PreviewDocumentIndex = __esm({
   "../src/runtime/dialogue-preview/PreviewDocumentIndex.ts"() {
     "use strict";
     init_value_row_owner_members();
+    init_user_safe_types();
     init_core();
     init_generics();
     init_read_class_member();
@@ -184528,7 +185271,65 @@ var init_PreviewDocumentIndex = __esm({
         }
         return ids;
       }
+      /** P104 §3.1. Previews run save-side, so User data is read-only. */
+      assertNotUserData(valueId) {
+        if (this.isUserRow(valueId)) {
+          throw new Error(USER_DATA_WRITE_ERROR);
+        }
+      }
+      /**
+       * P104 §3.3. Save data holds no User class instance and no reference to a
+       * User row, directly or through a closure's captures. `referenceId` maps a
+       * captured runtime value to the row it names.
+       */
+      assertSaveRow(row, referenceId4) {
+        const classId = row.classId;
+        if (typeof classId === "string" && this.storage.allowedStorage(classId) === 5 /* User */) {
+          const className = this.input.document.classes.find((entry) => entry.id === classId)?.name ?? classId;
+          throw new Error(
+            `\`${className}\` is a User class, so Save data can't hold it.`
+          );
+        }
+        const userRowId = this.userRowInlinedBy(row.value, referenceId4);
+        if (userRowId === null) return;
+        throw new Error(
+          `Save data can't hold a reference to \`root.User\` data. \`${this.field(userRowId)?.path ?? userRowId}\` is under \`root.User\`.`
+        );
+      }
+      /** A delegate row's value, or the inline delegates in a sparse row's entries. */
+      userRowInlinedBy(value, referenceId4) {
+        const direct = this.userRowReferencedBy(value, referenceId4, 0);
+        if (direct !== null || value === null || typeof value !== "object")
+          return direct;
+        for (const entry of Object.values(value)) {
+          const inlined = this.userRowReferencedBy(entry, referenceId4, 0);
+          if (inlined !== null) return inlined;
+        }
+        return null;
+      }
+      userRowReferencedBy(value, referenceId4, depth) {
+        if (isMemberDelegateTarget(value))
+          return value.valueId !== null && this.isUserRow(value.valueId) ? value.valueId : null;
+        if (isNSActionValue(value)) {
+          for (const listener of value.listeners)
+            if (listener.valueId !== null && this.isUserRow(listener.valueId))
+              return listener.valueId;
+          return null;
+        }
+        if (!isNSDelegateClosureValue(value) || depth > 64) return null;
+        for (const capture of value.captures ?? []) {
+          const nested = this.userRowReferencedBy(capture, referenceId4, depth + 1);
+          if (nested !== null) return nested;
+          const id2 = referenceId4(capture);
+          if (id2 !== null && this.isUserRow(id2)) return id2;
+        }
+        return null;
+      }
+      isUserRow(valueId) {
+        return this.field(valueId)?.storage === 5 /* User */;
+      }
       assertWritable(valueId) {
+        this.assertNotUserData(valueId);
         const field = this.field(valueId);
         if (field?.storage === 2 /* Save */ || field?.storage === 3 /* Session */)
           return;
@@ -184633,15 +185434,16 @@ var init_dialogue_dryrun_listeners = __esm({
             return void 0;
           return this.runtime.sourcesForCopy(ids);
         };
+        context.assertValueWritable = (id2) => this.index.assertNotUserData(id2);
+        context.assertActionInvocable = (id2) => this.index.assertNotUserData(id2);
         return context;
       }
       commit(result, context, apply) {
         this.context = context;
-        if (!this.hasDefaults && !this.runtime.hasOverrides && !evaluatedWrites(result).some((write) => write.kind === "changeListener")) {
-          apply(result, context);
-          return;
-        }
         apply(result, context);
+        this.assertSaveWrites(result, context);
+        if (!this.hasDefaults && !this.runtime.hasOverrides && !evaluatedWrites(result).some((write) => write.kind === "changeListener"))
+          return;
         context.vm = this.world.vm;
         context.rootValue = this.world.rootValue;
         this.copied = context.__copiedChangeListeners ?? this.copied;
@@ -184660,6 +185462,35 @@ var init_dialogue_dryrun_listeners = __esm({
         if (listenerWrites.length || adopted.size)
           this.runtime.prepare(listenerWrites, adopted).publish();
       }
+      /** P104 §3.3. The written Save rows hold no User instance or reference. */
+      assertSaveWrites(result, context) {
+        const referenceId4 = (value) => inspectNeoScriptValueReference(context, value)?.row.id ?? null;
+        const checked = /* @__PURE__ */ new Set();
+        const check2 = (id2) => {
+          if (checked.has(id2)) return;
+          checked.add(id2);
+          if (this.index.field(id2)?.storage !== 2 /* Save */) return;
+          const row = readNeoScriptRuntimeRow(context, id2);
+          if (row) this.index.assertSaveRow(row, referenceId4);
+        };
+        for (const write of evaluatedWrites(result)) {
+          if (write.kind === "changeListener") continue;
+          const destination = write.resolvedDestination;
+          if (destination !== void 0 && "containerValueId" in destination) {
+            const container = readNeoScriptRuntimeRow(
+              context,
+              destination.containerValueId
+            );
+            check2(destination.containerValueId);
+            const value = container?.value;
+            const slot = destination.key === void 0 || typeof value !== "object" || value === null ? void 0 : Reflect.get(value, destination.key);
+            if (typeof slot === "string") check2(slot);
+          }
+          if (!write.valueId) continue;
+          check2(write.valueId);
+          for (const id2 of this.index.descendantIds(write.valueId)) check2(id2);
+        }
+      }
     };
   }
 });
@@ -186267,7 +187098,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.71.4");
+    console.log("0.72.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {