@neocompose/cli 0.54.1 → 0.56.0

package/dist/neo.mjs

@@ -18769,13 +18769,15 @@ var init_project_schema_contract_generated = __esm({
           "Inherit",
           "Immutable",
           "Save",
-          "Session"
+          "Session",
+          "Writable"
         ],
         "NeoAllowedStorage": [
           "Any",
           "Immutable",
           "Save",
-          "Session"
+          "Session",
+          "Writable"
         ],
         "NeoListKind": [
           "Ordered",
@@ -22366,9 +22368,9 @@ function contextualAnnotationFields(document, position) {
       }
       const typeAnnotation = findTypeAnnotation(member.type, position);
       if (typeAnnotation) {
-        return fieldsForAnnotation(typeAnnotation.name, {
+        return fieldsForAnnotation(typeAnnotation.annotation.name, {
           kind: "type",
-          type: semanticType(member.type)
+          type: semanticType(typeAnnotation.type)
         });
       }
     }
@@ -22466,6 +22468,13 @@ function validateDeclaration(uri, declaration, documentKind, environment, diagno
     diagnostics
   );
   if (declaration.kind === "global") {
+    validateTypeAnnotations(
+      uri,
+      declaration.type,
+      "none",
+      environment,
+      diagnostics
+    );
     if (declaration.type.name === "Root") {
       validateProjectRootGlobal(uri, declaration, environment, diagnostics);
       return;
@@ -22507,11 +22516,26 @@ function validateDeclaration(uri, declaration, documentKind, environment, diagno
         validateTypeAnnotations(
           uri,
           parameter4.constraint,
+          "none",
           environment,
           diagnostics
         );
       }
     }
+    for (const parameter4 of declaration.headerParameters ?? []) {
+      validateTypeAnnotations(
+        uri,
+        parameter4.type,
+        "none",
+        environment,
+        diagnostics
+      );
+    }
+  }
+  if (declaration.kind === "class" || declaration.kind === "interface") {
+    for (const baseType of declaration.baseTypes) {
+      validateTypeAnnotations(uri, baseType, "none", environment, diagnostics);
+    }
   }
   const scope = new Map(environment.globals);
   if (declaration.kind === "class") {
@@ -22810,7 +22834,13 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
     environment,
     diagnostics
   );
-  validateTypeAnnotations(uri, member.type, environment, diagnostics);
+  validateTypeAnnotations(
+    uri,
+    member.type,
+    elementSettingsSite(member, documentKind),
+    environment,
+    diagnostics
+  );
   if (documentKind !== "flow") {
     validateListAnnotations(uri, member, ownerName, environment, diagnostics);
   }
@@ -22818,7 +22848,13 @@ function validateMember(uri, member, ownerName, documentKind, ownerScope, enviro
   if (member.kind === "function") {
     for (const parameter4 of member.parameters) {
       scope.set(parameter4.name, semanticType(parameter4.type));
-      validateTypeAnnotations(uri, parameter4.type, environment, diagnostics);
+      validateTypeAnnotations(
+        uri,
+        parameter4.type,
+        "none",
+        environment,
+        diagnostics
+      );
     }
     return;
   }
@@ -22919,16 +22955,77 @@ function validateFlowContent(uri, content, parentScope, environment, diagnostics
     }
   }
 }
-function validateTypeAnnotations(uri, type, environment, diagnostics) {
-  validateAnnotations(
+function elementSettingsSite(member, documentKind) {
+  if (documentKind === "flow" || member.kind !== "field") return "none";
+  const overrides = member.modifiers.includes("override") || member.modifiers.includes("sealed");
+  return overrides ? "override" : "declaringField";
+}
+function validateTypeAnnotations(uri, type, site, environment, diagnostics) {
+  rejectTypeAnnotations(
     uri,
-    type.annotations,
-    { kind: "type", type: semanticType(type) },
-    environment,
+    type,
+    "is not valid before a declared type. Annotate the declaration instead.",
     diagnostics
   );
-  for (const argument2 of type.typeArguments) {
-    validateTypeAnnotations(uri, argument2, environment, diagnostics);
+  validateTypeArgumentAnnotations(uri, type, site, environment, diagnostics);
+}
+function validateTypeArgumentAnnotations(uri, type, site, environment, diagnostics) {
+  const elementIndex = collectionElementIndex(type.name);
+  for (const [index, argument2] of type.typeArguments.entries()) {
+    const element = index === elementIndex;
+    if (!element) {
+      rejectTypeAnnotations(
+        uri,
+        argument2,
+        type.name === "Dictionary" ? "is not valid on a Dictionary key. Only the value type accepts element settings." : `is not valid on a ${type.name} type argument. Only a List element or Dictionary value accepts element settings.`,
+        diagnostics
+      );
+    } else if (site === "override") {
+      rejectTypeAnnotations(
+        uri,
+        argument2,
+        "is not valid on an override's element type. Declare element settings on the member that declares the collection.",
+        diagnostics
+      );
+    } else if (site === "none") {
+      rejectTypeAnnotations(
+        uri,
+        argument2,
+        "is not valid here. Only a field's List element or Dictionary value accepts element settings.",
+        diagnostics
+      );
+    } else {
+      validateAnnotations(
+        uri,
+        argument2.annotations,
+        { kind: "type", type: semanticType(argument2) },
+        environment,
+        diagnostics
+      );
+    }
+    validateTypeArgumentAnnotations(
+      uri,
+      argument2,
+      element ? site : "none",
+      environment,
+      diagnostics
+    );
+  }
+}
+function collectionElementIndex(name) {
+  if (name === "List") return 0;
+  if (name === "Dictionary") return 1;
+  return null;
+}
+function rejectTypeAnnotations(uri, type, reason, diagnostics) {
+  for (const annotation2 of type.annotations) {
+    pushDiagnostic(
+      diagnostics,
+      uri,
+      annotation2.nameRange,
+      "invalid-type-annotation",
+      `@${annotation2.name} ${reason}`
+    );
   }
 }
 function validateAnnotations(uri, annotations, context, environment, diagnostics) {
@@ -22997,6 +23094,7 @@ function fieldsForAnnotation(name, context, environment) {
     return context.kind === "class" ? [{ name: "visibility", type: "NeoClassVisibility" }] : null;
   }
   if (name === "settings") return settingsFields(context);
+  if (context.kind === "type") return null;
   if (name === "storage") return storageFields(context);
   if (name === "distribution") return distributionFields(context);
   if (name === "relations") return relationFields(context, environment);
@@ -23072,7 +23170,7 @@ function settingsFields(context) {
   );
 }
 function distributionFields(context) {
-  if (context.kind === "member" || context.kind === "type") {
+  if (context.kind === "member") {
     return [{ name: "kind", type: "NeoSubtreeDistribution" }];
   }
   return null;
@@ -23081,7 +23179,7 @@ function storageFields(context) {
   if (context.kind === "class") {
     return [{ name: "allowed", type: "NeoAllowedStorage" }];
   }
-  if (context.kind === "member" || context.kind === "type") {
+  if (context.kind === "member") {
     return [
       { name: "allowed", type: "NeoStorage" },
       { name: "key", type: "string?" }
@@ -24636,13 +24734,13 @@ function annotationEnumOption(annotations, name, field) {
   return match?.[1] ?? null;
 }
 function isListContext(context) {
-  return (context.kind === "member" || context.kind === "type") && (context.type.name === "List" || context.type.name === "Set");
+  return context.kind === "member" && (context.type.name === "List" || context.type.name === "Set");
 }
 function findTypeAnnotation(type, position) {
   const own = type.annotations.find(
     (annotation2) => inAnnotationArguments(annotation2, position)
   );
-  if (own) return own;
+  if (own) return { annotation: own, type };
   for (const argument2 of type.typeArguments) {
     const nested = findTypeAnnotation(argument2, position);
     if (nested) return nested;
@@ -31446,10 +31544,12 @@ function flowArguments(argumentsValue) {
   }));
 }
 function manifestType(type) {
+  const annotations = manifestAnnotations(type.annotations);
   return {
     name: type.name,
     nullable: type.nullable,
-    arguments: type.typeArguments.map(manifestType)
+    arguments: type.typeArguments.map(manifestType),
+    ...annotations.length === 0 ? {} : { annotations }
   };
 }
 function manifestAnnotations(annotations) {
@@ -31979,7 +32079,12 @@ function assertFlowArguments(value, path) {
 }
 function assertType(value, path) {
   const type = record(value, path);
-  exactKeys(type, path, ["name", "nullable", "arguments"]);
+  exactKeysWithOptional(
+    type,
+    path,
+    ["name", "nullable", "arguments"],
+    ["annotations"]
+  );
   string(type.name, `${path}.name`);
   if (typeof type.nullable !== "boolean") {
     throw new Error(`${path}.nullable must be boolean.`);
@@ -31987,6 +32092,10 @@ function assertType(value, path) {
   array(type.arguments, `${path}.arguments`).forEach(
     (argument2, index) => assertType(argument2, `${path}.arguments[${index}]`)
   );
+  if (type.annotations === void 0) return;
+  array(type.annotations, `${path}.annotations`).forEach(
+    (entry, index) => assertAnnotation(entry, `${path}.annotations[${index}]`)
+  );
 }
 function assertAnnotation(value, path) {
   const annotation2 = record(value, path);
@@ -32350,10 +32459,22 @@ function resolvedAllowedStorage(classId, environment) {
   }
   return null;
 }
-function staticDefaultWritability(classId, environment) {
-  const allowed = resolvedAllowedStorage(classId, environment);
+function constraintDefaultWritability(allowed) {
   return allowed === "immutable" || allowed === "save" || allowed === "session" ? allowed : "session";
 }
+function declaredStorageWritability(storage, staticOwnerClassId, environment) {
+  if (storage === "immutable" || storage === "save" || storage === "session") {
+    return storage;
+  }
+  if (storage === "writable") return "runtime";
+  if (!staticOwnerClassId) return void 0;
+  return staticDefaultWritability(staticOwnerClassId, environment);
+}
+function staticDefaultWritability(classId, environment) {
+  return constraintDefaultWritability(
+    resolvedAllowedStorage(classId, environment)
+  );
+}
 function createRootType(ids, environment) {
   const definitions = [
     ["Assets", ids.assets, false],
@@ -32415,7 +32536,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") {
+    if (member.storage === "immutable" || member.storage === "save" || member.storage === "session" || member.storage === "writable") {
       return member.storage;
     }
     return typeof member.overrideOf === "string" ? declaredStorage(member.overrideOf, seen) : null;
@@ -32438,8 +32559,8 @@ function effectiveMemberWritability(members, classes, roots) {
       seen.add(currentId);
       const current = classById.get(currentId);
       if (!current) break;
-      if (current.allowedStorage === "immutable" || current.allowedStorage === "save" || current.allowedStorage === "session") {
-        return current.allowedStorage;
+      if (typeof current.allowedStorage === "string") {
+        return constraintDefaultWritability(current.allowedStorage);
       }
       currentId = typeof current.extendsClassId === "string" ? current.extendsClassId : null;
     }
@@ -32474,6 +32595,7 @@ function effectiveMemberWritability(members, classes, roots) {
   }
   const effective = /* @__PURE__ */ new Map();
   const anchored = /* @__PURE__ */ new Set();
+  const writable = /* @__PURE__ */ new Set();
   const rootStorage = /* @__PURE__ */ new Map();
   if (typeof roots.assets === "string") {
     rootStorage.set(roots.assets, "immutable");
@@ -32483,16 +32605,19 @@ function effectiveMemberWritability(members, classes, roots) {
     rootStorage.set(roots.session, "session");
   }
   for (const [memberId, member] of memberById2) {
-    const root = rootStorage.get(memberId);
-    const declared = declaredStorage(memberId);
-    let storage = root ?? declared;
-    if (storage === void 0 || storage === null) {
+    const declared = rootStorage.get(memberId) ?? declaredStorage(memberId);
+    if (declared === "writable") {
+      writable.add(memberId);
+      continue;
+    }
+    let storage = declared;
+    if (storage === null) {
       const owner = optionalRecord(member.owner);
       if (member.modifier === "static" && owner?.kind === "classMember" && typeof owner.classId === "string") {
         storage = staticDefault(owner.classId);
       }
     }
-    if (storage === void 0 || storage === null) continue;
+    if (storage === null) continue;
     effective.set(memberId, /* @__PURE__ */ new Set([storage]));
     anchored.add(memberId);
   }
@@ -32502,8 +32627,11 @@ function effectiveMemberWritability(members, classes, roots) {
     for (const memberId of memberById2.keys()) {
       if (anchored.has(memberId)) continue;
       const next = new Set(effective.get(memberId) ?? []);
+      const isWritable = writable.has(memberId);
       for (const parentId of parents.get(memberId) ?? []) {
-        for (const storage of effective.get(parentId) ?? []) next.add(storage);
+        for (const storage of effective.get(parentId) ?? []) {
+          next.add(isWritable && storage === "immutable" ? "session" : storage);
+        }
       }
       const current = effective.get(memberId);
       if (current?.size === next.size || next.size === 0) continue;
@@ -32634,7 +32762,16 @@ function memberSymbol(member, schemaKey, environment, field) {
   }
   const writable = isReadOnly ? false : kind === "computed" ? computedHasSetter(member, field) : true;
   const storage = typeof member.storage === "string" ? member.storage : void 0;
-  const writability = isReadOnly ? "readOnly" : kind === "computed" ? writable ? "setter" : "readOnly" : !writable ? "readOnly" : storage === "immutable" || storage === "save" || storage === "session" ? storage : isStatic && ownerClassId ? staticDefaultWritability(ownerClassId, environment) : void 0;
+  let writability;
+  if (!writable) writability = "readOnly";
+  else if (kind === "computed") writability = "setter";
+  else {
+    writability = declaredStorageWritability(
+      storage,
+      isStatic ? ownerClassId : void 0,
+      environment
+    );
+  }
   const lookupCollectionMemberId = kind === "lookup" ? string2(member.collectionMemberId, `${field}.collectionMemberId`) : null;
   const lookupCollectionWritability = lookupCollectionMemberId === null ? void 0 : environment.effectiveWritabilityByMemberId.get(
     lookupCollectionMemberId
@@ -39996,7 +40133,13 @@ var init_codecs = __esm({
     };
     MEMBER_MODIFIERS = ["virtual", "sealed", "abstract", "static"];
     MEMBER_ACCESS = ["public", "protected", "private"];
-    MEMBER_STORAGE = ["inherit", "immutable", "save", "session"];
+    MEMBER_STORAGE = [
+      "inherit",
+      "immutable",
+      "save",
+      "session",
+      "writable"
+    ];
     MEMBER_DISTRIBUTION = ["sparse", "packed"];
     STRING_FORMAT = ["localized", "plain"];
     MEMBER_SEARCH_BY = ["none", "memberKey"];
@@ -40716,7 +40859,7 @@ function schemaClassToDocument(schemaClass2) {
     uiVisibility: schemaClass2.hiddenInMemberSelector ? 1 : void 0,
     modifier: schemaClass2.declarationModifier === "abstract" ? 1 : schemaClass2.declarationModifier === "sealed" ? 2 : void 0,
     system: systemToDocument(schemaClass2.system),
-    allowedStorage: schemaClass2.allowedStorage === null ? void 0 : ["immutable", "save", "session"].indexOf(schemaClass2.allowedStorage) + 1,
+    allowedStorage: schemaClass2.allowedStorage === null ? void 0 : CLASS_ALLOWED_STORAGE.indexOf(schemaClass2.allowedStorage),
     allowedStorageKeys: schemaClass2.allowedStorageKeys,
     // An unconstrained param is stored with no `constraint` key. The manifest
     // spells that absence `null` for a uniform in-memory shape, so emitting
@@ -40739,7 +40882,7 @@ function schemaClassToDocument(schemaClass2) {
 function allowedStorageFromDocument(value, record6) {
   const storage = ordinalValue(
     value ?? 0,
-    ["any", "immutable", "save", "session"],
+    CLASS_ALLOWED_STORAGE,
     record6,
     "allowedStorage"
   );
@@ -40786,12 +40929,19 @@ function optionalDocsTextProperty(value, record6) {
   const docsText = optionalDocsText(value, record6, "docsText");
   return docsText === void 0 ? {} : { docsText };
 }
-var CLASS_SCHEMA_RECORD_ADAPTER;
+var CLASS_ALLOWED_STORAGE, CLASS_SCHEMA_RECORD_ADAPTER;
 var init_class = __esm({
   "src/project-manifest/record-adapters/class.ts"() {
     "use strict";
     init_contracts();
     init_codecs();
+    CLASS_ALLOWED_STORAGE = [
+      "any",
+      "immutable",
+      "save",
+      "session",
+      "writable"
+    ];
     CLASS_SCHEMA_RECORD_ADAPTER = {
       recordKind: "class",
       manifestCollection: "classes",
@@ -42892,7 +43042,7 @@ var init_schema_member = __esm({
       defaultValue: nullable(schemaDefaultValueSchema),
       overrideOf: nullableId2,
       system: nullable(schemaSystemMetadataSchema),
-      storage: nullable(picklist(["immutable", "save", "session"])),
+      storage: nullable(picklist(["immutable", "save", "session", "writable"])),
       distribution: nullable(picklist(["sparse", "packed"])),
       storageKey: nullableId2
     };
@@ -44558,7 +44708,7 @@ function booleanAt(value, path) {
 }
 function nullableStorage(value, path) {
   if (value === null) return;
-  stringIn(value, /* @__PURE__ */ new Set(["immutable", "save", "session"]), path);
+  stringIn(value, /* @__PURE__ */ new Set(["immutable", "save", "session", "writable"]), path);
 }
 function stringIn(value, allowed, path) {
   const result = stringAt(value, path);
@@ -45327,15 +45477,59 @@ var init_class_generics = __esm({
 
 // ../src/models/members/member-storage.ts
 function isMemberStorageKind(value) {
-  return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */;
+  return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 4 /* Writable */;
 }
 function isEffectiveMemberStorage(value) {
+  return value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */;
+}
+function isClassAllowedStorage(value) {
   if (!isMemberStorageKind(value)) return false;
   return value !== 0 /* Inherit */;
 }
+function childEffectiveStorage(declared, parent) {
+  switch (declared) {
+    case 0 /* Inherit */:
+      return parent;
+    case 4 /* Writable */:
+      return parent === 2 /* Save */ ? 2 /* Save */ : 3 /* Session */;
+    default:
+      return declared;
+  }
+}
+function constraintDefaultStorage(constraint) {
+  if (constraint === null) return 3 /* Session */;
+  if (constraint === 4 /* Writable */) {
+    return 3 /* Session */;
+  }
+  return constraint;
+}
+function createWritableAncestorLookup(memberById2) {
+  const memo = /* @__PURE__ */ new Map();
+  const lookup = (member) => {
+    const cached = memo.get(member.id);
+    if (cached !== void 0) return cached;
+    memo.set(member.id, null);
+    const baseId = member.extendsMemberId;
+    const base = baseId === void 0 ? void 0 : memberById2(baseId);
+    if (base === void 0) return null;
+    const result = base.storage === 4 /* Writable */ ? base : lookup(base);
+    memo.set(member.id, result);
+    return result;
+  };
+  return lookup;
+}
+var MemberStorageKind;
 var init_member_storage = __esm({
   "../src/models/members/member-storage.ts"() {
     "use strict";
+    MemberStorageKind = /* @__PURE__ */ ((MemberStorageKind3) => {
+      MemberStorageKind3[MemberStorageKind3["Inherit"] = 0] = "Inherit";
+      MemberStorageKind3[MemberStorageKind3["Immutable"] = 1] = "Immutable";
+      MemberStorageKind3[MemberStorageKind3["Save"] = 2] = "Save";
+      MemberStorageKind3[MemberStorageKind3["Session"] = 3] = "Session";
+      MemberStorageKind3[MemberStorageKind3["Writable"] = 4] = "Writable";
+      return MemberStorageKind3;
+    })(MemberStorageKind || {});
   }
 });
 
@@ -47312,7 +47506,7 @@ function isNeoSchemaClassBase(value) {
   const v = value;
   return typeof v?.name === "string" && isValidDocsText(v.docsText) && isClassSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && (v.implementsInterfaceIds === void 0 || Array.isArray(v.implementsInterfaceIds) && v.implementsInterfaceIds.every(
     (interfaceId) => typeof interfaceId === "string" && interfaceId.length > 0
-  )) && (v.uiVisibility === void 0 || v.uiVisibility === 0 /* Visible */ || v.uiVisibility === 1 /* Hidden */) && (v.modifier === void 0 || v.modifier === 0 /* Open */ || v.modifier === 1 /* Abstract */ || v.modifier === 2 /* Sealed */) && (v.allowedStorage === void 0 || isEffectiveMemberStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || Array.isArray(v.constructorIds) && v.constructorIds.every(
+  )) && (v.uiVisibility === void 0 || v.uiVisibility === 0 /* Visible */ || v.uiVisibility === 1 /* Hidden */) && (v.modifier === void 0 || v.modifier === 0 /* Open */ || v.modifier === 1 /* Abstract */ || v.modifier === 2 /* Sealed */) && (v.allowedStorage === void 0 || isClassAllowedStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || Array.isArray(v.constructorIds) && v.constructorIds.every(
     (constructorId) => typeof constructorId === "string" && constructorId.length > 0
   ) && new Set(v.constructorIds).size === v.constructorIds.length) && (v.requiredConstructorId === void 0 || typeof v.requiredConstructorId === "string" && v.requiredConstructorId.length > 0 && (v.constructorIds ?? []).length === 0) && (v.targetMemberId === void 0 || typeof v.targetMemberId === "string" && v.targetMemberId.length > 0) && (v.system === void 0 || isSystemMetadata(v.system));
 }
@@ -52913,7 +53107,7 @@ function assertOwnedSchemaIsImmutable(args) {
   const bindingKey = `${args.memberId}\0${genericEnvironmentKey(args.genericEnv)}`;
   if (args.visitedBindings.has(bindingKey)) return;
   args.visitedBindings.add(bindingKey);
-  if (resolved.storage === 2 /* Save */ || resolved.storage === 3 /* Session */) {
+  if (resolved.storage === 2 /* Save */ || resolved.storage === 3 /* Session */ || resolved.storage === 4 /* Writable */) {
     throw new Error(
       `Read-only member "${args.label}" has a non-Immutable owned default child "${resolved.name}"; ${args.ownerContext}.`
     );
@@ -56804,6 +56998,9 @@ var init_effective_storage = __esm({
       schemaIndex;
       parentIdsByMemberId = /* @__PURE__ */ new Map();
       effectiveByMemberId = /* @__PURE__ */ new Map();
+      writableAncestor = createWritableAncestorLookup(
+        (id2) => this.schemaIndex.member(id2)
+      );
       resolving = /* @__PURE__ */ new Set();
       /** Declared storage of `memberId`, resolved through the extends chain. */
       declaredStorage(memberId) {
@@ -56812,6 +57009,15 @@ var init_effective_storage = __esm({
           this.schemaIndex.membersById
         );
       }
+      /**
+       * Nearest member in `memberId`'s `extendsMemberId` chain, excluding itself,
+       * whose own record declares `Writable` (P93 §1.4), or null.
+       */
+      writableAncestorId(memberId) {
+        const member = this.schemaIndex.member(memberId);
+        if (member === void 0) return null;
+        return this.writableAncestor(member)?.id ?? null;
+      }
       /** Placement-parent member ids of `memberId` (empty for roots). */
       parentMemberIds(memberId) {
         if (this.ctx.rootStorage.has(memberId)) return [];
@@ -56835,21 +57041,21 @@ var init_effective_storage = __esm({
             result.add(rootStorage);
           } else {
             const declared = this.declaredStorage(memberId);
-            const member = this.schemaIndex.member(memberId);
-            if (isStaticMember(member) === true) {
-              if (declared !== 0 /* Inherit */) {
-                result.add(declared);
-              } else {
-                const declaringClassId = this.schemaIndex.firstSchemaPlacement(memberId)?.ownerClass.id;
-                const inherited = declaringClassId === void 0 ? null : resolveAllowedStorage(declaringClassId, this.ctx.classes);
-                result.add(inherited ?? 3 /* Session */);
-              }
-            } else if (declared !== 0 /* Inherit */) {
+            if (isEffectiveMemberStorage(declared)) {
               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);
+              result.add(
+                childEffectiveStorage(
+                  declared,
+                  constraintDefaultStorage(constraint)
+                )
+              );
             } else {
               for (const parentId of this.parentMemberIds(memberId)) {
                 for (const storage of this.effectiveStorages(parentId)) {
-                  result.add(storage);
+                  result.add(childEffectiveStorage(declared, storage));
                 }
               }
             }
@@ -56864,26 +57070,44 @@ var init_effective_storage = __esm({
        * Effective storage for one concrete placement chain, ordered root-first
        * (the project root at index 0, the target member last). Used when the
        * caller knows the exact path (NeoScript member walks, value trees).
+       * Anchors at the root, the nearest concrete declaration, or a single-storage
+       * static head, then folds the members below through `childEffectiveStorage`.
        */
       effectiveStorageForPath(memberIdsRootToLeaf) {
-        for (let i = memberIdsRootToLeaf.length - 1; i >= 0; i--) {
-          const memberId = memberIdsRootToLeaf[i];
-          const rootStorage = this.ctx.rootStorage.get(memberId);
-          if (rootStorage !== void 0 && i === 0) return rootStorage;
+        let anchorIndex = memberIdsRootToLeaf.length - 1;
+        let storage;
+        for (; anchorIndex >= 0; anchorIndex--) {
+          const memberId = memberIdsRootToLeaf[anchorIndex];
+          if (anchorIndex === 0) storage = this.ctx.rootStorage.get(memberId);
+          if (storage !== void 0) break;
           const declared = this.declaredStorage(memberId);
-          if (declared !== 0 /* Inherit */) return declared;
+          if (isEffectiveMemberStorage(declared)) {
+            storage = declared;
+            break;
+          }
+        }
+        if (storage === void 0) {
+          anchorIndex = 0;
+          storage = this.staticRootStorage(memberIdsRootToLeaf[0]);
         }
-        const rootId = memberIdsRootToLeaf[0];
-        const anchored = rootId === void 0 ? void 0 : this.ctx.rootStorage.get(rootId);
-        if (anchored !== void 0) return anchored;
+        for (let i = anchorIndex + 1; i < memberIdsRootToLeaf.length; i++) {
+          storage = childEffectiveStorage(
+            this.declaredStorage(memberIdsRootToLeaf[i]),
+            storage
+          );
+        }
+        return storage;
+      }
+      /** A static chain head's storage when it resolves to exactly one. */
+      staticRootStorage(rootId) {
         if (rootId !== void 0 && isStaticMember(this.schemaIndex.member(rootId))) {
           const staticStorages = this.effectiveStorages(rootId);
           if (staticStorages.size === 1) {
-            return staticStorages.values().next().value;
+            for (const storage of staticStorages) return storage;
           }
         }
         throw new Error(
-          `Storage path did not resolve: no member in the chain declares a storage class and the chain head "${rootId ?? "(empty)"}" is not a stamped project root.`
+          `Storage path did not resolve: no member in the chain declares an Immutable, Save, or Session storage class and the chain head "${rootId ?? "(empty)"}" is not a stamped project root.`
         );
       }
       /** Class's merged (inheritance-resolved) schema. */
@@ -58134,7 +58358,12 @@ ${signature} => ${expression};`;
     context.formAlternates.push({ shorthand, block });
     return shorthand;
   }
-  const type = renderMemberType(context, member, enclosingClassId);
+  const type = renderMemberType(
+    context,
+    member,
+    enclosingClassId,
+    member.overrideOf === null
+  );
   const initializer = initDefaultSource(member) ?? (member.modifier === "static" ? context.staticInitializers.get(member.id) : void 0) ?? context.defaultInitializers.get(member.id) ?? renderDefault(context, member, enclosingClassId);
   return `${annotations.join("\n")}
 ${prefix}${type} ${member.name}${initializer === null ? ";" : ` = ${initializer};`}`;
@@ -58271,7 +58500,18 @@ function listAnnotations(member) {
     })
   ];
 }
-function renderMemberType(context, member, enclosingClassId) {
+function renderEntryType(context, entryMemberId, label, enclosingClassId, elementSettings) {
+  const entry = required(context.members, entryMemberId, label);
+  const type = renderMemberType(
+    context,
+    entry,
+    enclosingClassId,
+    elementSettings
+  );
+  const settings = elementSettings ? memberSettings(context, entry) : [];
+  return settings.length === 0 ? type : `${settings.join(" ")} ${type}`;
+}
+function renderMemberType(context, member, enclosingClassId, elementSettings = false) {
   const nullable2 = !member.required;
   const closedGenerics = enclosingClassId === void 0 ? void 0 : classGenericMemberBindings(context.classes, enclosingClassId);
   let value;
@@ -58362,11 +58602,11 @@ function renderMemberType(context, member, enclosingClassId) {
       break;
     }
     case "list":
-      value = `List<${renderMemberType(context, required(context.members, member.entryMemberId, "list entry"), enclosingClassId)}>`;
+      value = `List<${renderEntryType(context, member.entryMemberId, "list entry", enclosingClassId, elementSettings)}>`;
       break;
     case "dictionary": {
       const key = member.key.kind === "string" ? "string" : required(context.enums, member.key.enumId, "dictionary key enum").name;
-      value = `Dictionary<${key}, ${renderMemberType(context, required(context.members, member.entryMemberId, "dictionary entry"), enclosingClassId)}>`;
+      value = `Dictionary<${key}, ${renderEntryType(context, member.entryMemberId, "dictionary entry", enclosingClassId, elementSettings)}>`;
       break;
     }
     case "lookup": {
@@ -64088,6 +64328,14 @@ function buildRootStorageMap(project) {
   }
   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);
 }
@@ -64679,7 +64927,9 @@ function symbolWritability(memberId, context, staticOwnerClassId) {
   if (storage === 0 /* Inherit */ && staticOwnerClassId === null) {
     return {};
   }
-  const effectiveStorage = storage === 0 /* Inherit */ ? resolveAllowedStorage(staticOwnerClassId, context.vm.classes) ?? 3 /* Session */ : storage;
+  const effectiveStorage = storage === 0 /* Inherit */ ? constraintDefaultStorage(
+    resolveAllowedStorage(staticOwnerClassId, context.vm.classes)
+  ) : storage;
   switch (effectiveStorage) {
     case 1 /* Immutable */:
       return { writability: "immutable" };
@@ -64687,6 +64937,8 @@ function symbolWritability(memberId, context, staticOwnerClassId) {
       return { writability: "save" };
     case 3 /* Session */:
       return { writability: "session" };
+    case 4 /* Writable */:
+      return { writability: "runtime" };
   }
 }
 function uniqueEffectiveWritability(memberId, context) {
@@ -90556,6 +90808,68 @@ function resolveLocalizableStringWriteOwners(document, changes, requestedValueId
   }
   return owners;
 }
+function packedLocalizationConversionChanges(args) {
+  const beforeById = new Map(
+    args.beforeMembers.map((member) => [member.id, member])
+  );
+  const becameLocalized = (member) => {
+    if (!isMemberStringBase(member)) return false;
+    if (!isLocalizedStringMember(member)) return false;
+    const id2 = getOptionalString(member, "id");
+    const before = id2 === void 0 ? void 0 : beforeById.get(id2);
+    if (before === void 0) return false;
+    const resolved = resolveMember2(before, args.beforeMembers);
+    return isMemberStringBase(resolved) && !isLocalizedStringMember(resolved);
+  };
+  const postMembers = new Map(
+    args.postDocument.members.map((member) => [member.id, member])
+  );
+  const flips = args.changes.some((change) => {
+    if (change.recordKind !== "member" || change.operation === "delete") {
+      return false;
+    }
+    const member = postMembers.get(change.recordId);
+    return member !== void 0 && becameLocalized(resolveMember2(member, args.postDocument.members));
+  });
+  if (!flips) return [];
+  const changedValueIds = new Set(
+    args.changes.flatMap(
+      (change) => change.recordKind === "value" ? [change.recordId] : []
+    )
+  );
+  const omitted = /* @__PURE__ */ new Map();
+  for (const change of args.submitted) {
+    if (change.recordKind !== "value" || change.operation === "delete") {
+      continue;
+    }
+    if (!isMemberValue(change.nextData)) continue;
+    for (const child of decodePackedValueRow(change.nextData).children) {
+      if (changedValueIds.has(child.id)) continue;
+      if (typeof child.value !== "string" || child.value === "") continue;
+      omitted.set(child.id, { child, intent: change.intent });
+    }
+  }
+  if (omitted.size === 0) return [];
+  const owners = resolveLocalizableStringWriteOwners(
+    args.postDocument,
+    args.changes,
+    new Set(omitted.keys())
+  );
+  const conversions = [];
+  for (const [valueId, { child, intent }] of omitted) {
+    const owner = owners.get(valueId);
+    if (owner === void 0 || !becameLocalized(owner)) continue;
+    conversions.push({
+      intent,
+      recordKind: "value",
+      recordId: valueId,
+      operation: "update",
+      deleted: false,
+      nextData: child
+    });
+  }
+  return conversions;
+}
 function reconcileMemberTextUsage(document, changes, before, referencedOutsideDocument, now, contentHashByKey) {
   const assignmentChanges = changes.filter(
     (change) => change.recordKind === "member" || change.recordKind === "value"
@@ -90828,6 +91142,7 @@ var init_localizable_member_value_writes = __esm({
     init_project_record_live_references();
     init_localization2();
     init_members();
+    init_packed_value_encoding();
     init_variant_value_graph();
     init_project_version_intents();
     init_constructor_argument_ownership();
@@ -91219,10 +91534,11 @@ function commitPreparationMemberDefaultValueScope(args) {
   return { exactValueIds, descendantValueIds, evaluatesSource };
 }
 function planCommitPreparationInitialScope(args) {
+  const submitted = args.changes;
   args = {
     ...args,
     changes: expandPackedValueWriteChanges({
-      changes: args.changes,
+      changes: submitted,
       baseValues: args.document.values ?? [],
       basePhysicalValues: args.document.physicalValues,
       omitUnchangedChildren: true
@@ -91233,6 +91549,18 @@ function planCommitPreparationInitialScope(args) {
   );
   const currentDocument = overlayPlanningDocument(args.document, []);
   const postDocument = overlayPlanningDocument(currentDocument, args.changes);
+  args = {
+    ...args,
+    changes: [
+      ...args.changes,
+      ...packedLocalizationConversionChanges({
+        submitted,
+        changes: args.changes,
+        beforeMembers: currentDocument.members,
+        postDocument
+      })
+    ]
+  };
   const exactRecords = /* @__PURE__ */ new Map();
   const descendantRecords = /* @__PURE__ */ new Map();
   const rememberExact = (recordKind, recordId, includeDescendants = false) => {
@@ -91722,8 +92050,13 @@ function planCommitPreparationLoadedClosureScope(args) {
     postings.set(commitPreparationPostingRequestKey(posting), posting);
   };
   for (const record6 of args.records) {
-    if (record6.recordKind === "value" && isMemberValue(record6.data) && typeof record6.data.value === "string" && record6.data.value !== "") {
-      rememberExact("localized-text", record6.data.value);
+    if (record6.recordKind === "value" && isMemberValue(record6.data)) {
+      const decoded = decodePackedValueRow(record6.data);
+      for (const row of [decoded.row, ...decoded.children]) {
+        if (typeof row.value === "string" && row.value !== "") {
+          rememberExact("localized-text", row.value);
+        }
+      }
     }
     if (record6.recordKind === "member" && isMemberStringBase(record6.data) && isLocalizedStringMember(record6.data) && typeof record6.data.defaultValue?.value === "string" && record6.data.defaultValue.value !== "") {
       rememberExact("localized-text", record6.data.defaultValue.value);
@@ -97069,6 +97402,14 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
       true
     );
   authoredChanges = retargeted;
+  authoredChanges.push(
+    ...packedLocalizationConversionChanges({
+      submitted: args.changes,
+      changes: authoredChanges,
+      beforeMembers: args.document.members,
+      postDocument: authoredPost
+    })
+  );
   const editedValueIds = new Set(
     authoredChanges.filter(
       (change) => change.recordKind === "value" && change.operation === "update"
@@ -101163,10 +101504,6 @@ var init_unity_static_members = __esm({
 });
 
 // ../src/models/animation/animation-clips.ts
-function isWorldAnimationStructuralMember(memberId, members) {
-  const membersById = new Map(members.map((member) => [member.id, member]));
-  return isWorldAnimationStructuralMemberFromIndex(memberId, membersById);
-}
 function isWorldAnimationStructuralMemberFromIndex(memberId, membersById) {
   const visited = /* @__PURE__ */ new Set();
   let currentId = memberId;
@@ -101177,6 +101514,35 @@ function isWorldAnimationStructuralMemberFromIndex(memberId, membersById) {
   }
   return false;
 }
+function worldOverridePathIsStructurallyEligible(memberIdsRootToLeaf, membersById) {
+  for (const memberId of memberIdsRootToLeaf) {
+    if (isWorldAnimationStructuralMemberFromIndex(memberId, membersById)) {
+      return false;
+    }
+    const member = membersById.get(memberId);
+    if (member === void 0) return false;
+    const resolved = resolveMemberFromIndex(member, membersById);
+    if (isStaticMember(resolved) || isReadOnlyMember(resolved)) return false;
+    if (resolved.kind === 13 /* Function */ || resolved.kind === 23 /* NSFunction */ || resolved.kind === 10 /* NSProperty */ || resolved.kind === 6 /* List */ || resolved.kind === 5 /* Dictionary */) {
+      return false;
+    }
+  }
+  return true;
+}
+function animationTrackStorage(memberIdsRootToLeaf, membersById, childrenPrefix = []) {
+  if (!worldOverridePathIsStructurallyEligible(memberIdsRootToLeaf, membersById)) {
+    return null;
+  }
+  const path = [...childrenPrefix, ...memberIdsRootToLeaf];
+  for (let index = path.length - 1; index >= 0; index -= 1) {
+    const memberId = path[index];
+    if (memberId === void 0) continue;
+    const storage = declaredMemberStorageFromIndex(memberId, membersById);
+    if (storage === 0 /* Inherit */) continue;
+    return storage === 1 /* Immutable */ ? null : storage;
+  }
+  return null;
+}
 function assertAnimationClipDocumentValid(document, scope) {
   const context = new AnimationValidationContext(document);
   context.validateSegments(scope);
@@ -101204,7 +101570,6 @@ var init_animation_clips = __esm({
     init_member_storage();
     init_neoscript_types();
     init_neoscript_guards();
-    init_project_root_members();
     init_members();
     WORLD_ANIMATION_STRUCTURAL_MEMBER_ROOT_IDS = /* @__PURE__ */ new Set([
       WORLD_GRID_CHILDREN_MEMBER_ID,
@@ -101230,17 +101595,11 @@ var init_animation_clips = __esm({
           document.members.map((value) => [value.id, value])
         );
         this.valueById = new Map(document.values.map((value) => [value.id, value]));
-        this.storage = new EffectiveStorageResolver({
-          classes: document.classes,
-          members: document.members,
-          rootStorage: buildRootStorageMap(document.project)
-        });
       }
       document;
       classById;
       memberById;
       valueById;
-      storage;
       classHasWorldKind(classId, worldKind) {
         const visited = /* @__PURE__ */ new Set();
         let current = this.classById.get(classId);
@@ -101316,6 +101675,7 @@ var init_animation_clips = __esm({
               definitionNode: targetDefinition,
               memberPath: [],
               storagePath: [],
+              childrenPrefix: [],
               visited: /* @__PURE__ */ new Set()
             });
           }
@@ -101400,7 +101760,8 @@ var init_animation_clips = __esm({
               overrideNode: overrides,
               definitionNode: child,
               memberPath: [`child:${childId}`],
-              storagePath: [...args.childStoragePath],
+              storagePath: [],
+              childrenPrefix: args.childStoragePath,
               visited: /* @__PURE__ */ new Set()
             });
           }
@@ -101743,12 +102104,13 @@ var init_animation_clips = __esm({
             `${args.label} targets "${boundChildName}.${targetEntry.schemaKey}" of kind ${MemberKind[targetMember.kind]}, but its segment plays ${MemberKind[valueBindingMember.kind]} values.`
           );
         }
-        if (!this.overrideLeafEligible(targetMember, [
-          ...args.childStoragePath,
-          targetMember.id
-        ])) {
+        if (!this.overrideLeafEligible(
+          targetMember,
+          [targetMember.id],
+          args.childStoragePath
+        )) {
           throw new Error(
-            `${args.label} targets "${boundChildName}.${targetEntry.schemaKey}", which is not a writable Save/Session override leaf.`
+            `${args.label} targets "${boundChildName}.${targetEntry.schemaKey}", which is not a writable Save, Session, or Writable override leaf.`
           );
         }
       }
@@ -101918,7 +102280,8 @@ var init_animation_clips = __esm({
                 partial: overrideChild.value,
                 path,
                 schemaKey,
-                storagePath: args.storagePath
+                storagePath: args.storagePath,
+                childrenPrefix: args.childrenPrefix
               });
               continue;
             }
@@ -101949,9 +102312,13 @@ var init_animation_clips = __esm({
               });
               continue;
             }
-            if (!this.overrideLeafEligible(member, [...args.storagePath, member.id])) {
+            if (!this.overrideLeafEligible(
+              member,
+              [...args.storagePath, member.id],
+              args.childrenPrefix
+            )) {
               throw new Error(
-                `Animation clip "${args.clipName}" frame ${args.frameIndex} member "${path.join(".")}" is not a writable Save/Session override leaf.`
+                `Animation clip "${args.clipName}" frame ${args.frameIndex} member "${path.join(".")}" is not a writable Save, Session, or Writable override leaf.`
               );
             }
           }
@@ -101986,12 +102353,13 @@ var init_animation_clips = __esm({
           );
         }
         const kindLabel = MemberKind[kind];
-        if (!this.overrideLeafEligible(args.member, [
-          ...args.storagePath,
-          args.member.id
-        ])) {
+        if (!this.overrideLeafEligible(
+          args.member,
+          [...args.storagePath, args.member.id],
+          args.childrenPrefix
+        )) {
           throw new Error(
-            `${prefix} ${kindLabel} member "${memberPath3}" cannot take a "${STRUCTURED_LEAF_PARTIAL_KEY}" field override; member "${args.member.name}" is not a writable Save/Session override leaf.`
+            `${prefix} ${kindLabel} member "${memberPath3}" cannot take a "${STRUCTURED_LEAF_PARTIAL_KEY}" field override; member "${args.member.name}" is not a writable Save, Session, or Writable override leaf.`
           );
         }
         const violation = structuredLeafPartialViolation(
@@ -102032,24 +102400,9 @@ var init_animation_clips = __esm({
           throw new Error(`${descent}; its value is not a ${kindLabel} record.`);
         }
       }
-      overrideLeafEligible(member, storagePath) {
-        if (isReadOnlyMember(member) === true || isStaticMember(member))
-          return false;
-        if (isWorldAnimationStructuralMember(member.id, this.document.members)) {
-          return false;
-        }
-        if (member.kind === 13 /* Function */ || member.kind === 23 /* NSFunction */ || member.kind === 10 /* NSProperty */ || member.kind === 7 /* Class */ || member.kind === 6 /* List */ || member.kind === 5 /* Dictionary */) {
-          return false;
-        }
-        try {
-          const storage = this.storage.effectiveStorageForPath(storagePath);
-          return storage === 2 /* Save */ || storage === 3 /* Session */;
-        } catch {
-          const storages = this.storage.effectiveStorages(member.id);
-          return storages.size > 0 && [...storages].every(
-            (storage) => storage === 2 /* Save */ || storage === 3 /* Session */
-          );
-        }
+      overrideLeafEligible(member, storagePath, childrenPrefix) {
+        if (member.kind === 7 /* Class */) return false;
+        return animationTrackStorage(storagePath, this.memberById, childrenPrefix) !== null;
       }
       authoredChildren(targetClassId, definitionNode) {
         const childEntry = mergeStoredInstanceSchema(
@@ -102073,9 +102426,8 @@ var init_animation_clips = __esm({
               (value) => typeof value === "string"
             ) : []
           ),
-          // Child values inherit storage from their concrete placement under the
-          // owner's resolved Children member. This mirrors the authoring panel's
-          // storage path instead of treating a shared child-class leaf as a root.
+          // P93 §5: a child track's declaration walk continues through the
+          // owner's resolved Children member, as the authoring pane's does.
           storagePath: [childEntry.memberId]
         };
       }
@@ -103038,7 +103390,7 @@ function readClass(value) {
     CLASS_VISIBILITY_KINDS,
     `${label} uiVisibility`
   );
-  if (value.allowedStorage != null && !isEffectiveMemberStorage(value.allowedStorage)) {
+  if (value.allowedStorage != null && !isClassAllowedStorage(value.allowedStorage)) {
     throw new Error(`${label} allowedStorage is invalid.`);
   }
   if (value.genericParams !== void 0 && value.genericParams !== null) {
@@ -103420,6 +103772,14 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
   const classes = view.classes.map(readClass);
   const interfaces = view.interfaces.map(readInterface);
   const membersById = new Map(members.map((member) => [member.id, member]));
+  for (const [rootId, stamped] of view.rootStorage ?? []) {
+    const root = membersById.get(rootId);
+    if (root === void 0 || root.storage === stamped) continue;
+    const declared = root.storage === void 0 ? "none" : MemberStorageKind[root.storage];
+    throw new Error(
+      `Project root member "${root.name}" (${rootId}) must declare ${MemberStorageKind[stamped]} storage but declares ${declared}.`
+    );
+  }
   const classesById = new Map(
     classes.map((schemaClass2) => [schemaClass2.id, schemaClass2])
   );
@@ -103539,6 +103899,11 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         `Static member "${member.name}" (${member.id}) must be a plain non-override member.`
       );
     }
+    if (member.storage === 4 /* Writable */) {
+      throw new Error(
+        `Static member "${member.name}" (${member.id}) cannot declare Writable storage; a static member has no placement parent to resolve it against.`
+      );
+    }
     if (member.kind === 21) {
       throw new Error(
         `Generic placeholder member "${member.name}" (${member.id}) cannot be static.`
@@ -103843,6 +104208,19 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     if (member.mutability === void 0) delete resolved.mutability;
     return resolved;
   };
+  const writableAncestor2 = createWritableAncestorLookup(
+    (id2) => membersById.get(id2)
+  );
+  for (const member of members) {
+    if (member.storage !== 1 /* Immutable */ && member.storage !== 0 /* Inherit */) {
+      continue;
+    }
+    const ancestor = writableAncestor2(member);
+    if (ancestor === null) continue;
+    throw new Error(
+      `Member "${member.name}" (${member.id}) declares ${MemberStorageKind[member.storage]} storage but overrides Writable member "${ancestor.name}" (${ancestor.id}); an override of a Writable member may declare Writable, Save, or Session, or omit storage.`
+    );
+  }
   const rootAndEntryMemberIds = /* @__PURE__ */ new Set();
   for (const owner of members) {
     if (typeof owner.entryMemberId === "string") {
@@ -103984,7 +104362,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         }
       }
       if (rawOwned.id === member.id && isAbstractMember(member)) return;
-      if (owned.storage === 2 /* Save */ || owned.storage === 3 /* Session */) {
+      if (owned.storage === 2 /* Save */ || owned.storage === 3 /* Session */ || owned.storage === 4 /* Writable */) {
         throw new Error(
           `Read-only member "${member.name}" has a non-Immutable owned default child "${owned.name}"; ${ownerLabel}.`
         );
@@ -104515,7 +104893,7 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       return resolved.setterCode === void 0 ? "NSProperty has no setter implementation." : null;
     }
     const storage = resolved.storage;
-    if (storage === 2 /* Save */ || storage === 3 /* Session */) {
+    if (storage === 2 /* Save */ || storage === 3 /* Session */ || storage === 4 /* Writable */) {
       return null;
     }
     if (storage === 1 /* Immutable */) {
@@ -106553,6 +106931,14 @@ function assertStagedProjectInterfaceValid(projected, changes) {
       variants: projected.variants ?? [],
       variantFolders: projected.variantFolders ?? [],
       interfaces: projected.interfaces,
+      rootStorage: writtenRootStorage(
+        projected.project,
+        new Set(
+          changes.flatMap(
+            (change) => change.recordKind === "member" ? [change.recordId] : []
+          )
+        )
+      ),
       values: projected.values
     },
     {
@@ -107148,6 +107534,7 @@ var init_project_version_whole_graph_validation = __esm({
     init_core();
     init_animation_clips();
     init_projectInterfaceValidation();
+    init_project_root_members();
     init_project_schema_identifier_validation();
     init_packed_value_write_fold();
     init_project_version_schema_commit();
@@ -109196,7 +109583,15 @@ function lowerMemberKind(context, ownerClass, declaration, id2, owner) {
       deferred: declaration.modifiers.includes("async")
     };
   }
-  return lowerFieldMember(context, ownerClass, declaration, id2, common, base);
+  return lowerFieldMember(
+    context,
+    ownerClass,
+    declaration,
+    id2,
+    common,
+    base,
+    "declaration"
+  );
 }
 function lowerUiFunctionAction(context, ownerName, declaration, base, memberId, sourceText) {
   const compiled = context.compiledFunctionBodiesByMemberId.get(memberId) ?? context.compiledFunctionBodiesBySourceName.get(
@@ -109267,6 +109662,7 @@ function memberCommon(context, ownerClass, declaration, id2, owner, base) {
   const storage = annotation(declaration.annotations, "storage");
   const distribution = annotation(declaration.annotations, "distribution");
   const inheritedId = declaration.modifiers.includes("override") || declaration.modifiers.includes("sealed") ? inheritedMemberId(context, ownerClass, declaration.name) : null;
+  assertWritableStorageRules(context, ownerClass, declaration, inheritedId);
   return {
     id: id2,
     source: sourceIdentity2(declaration, "member", declaration.name),
@@ -109343,7 +109739,7 @@ function resolvedMemberStorage(context, memberId, visited = /* @__PURE__ */ new
   }
   return null;
 }
-function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, base) {
+function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, base, entrySettings) {
   const partial = declaration.type.name === "Partial";
   const fieldType = partial ? requiredTypeArgument(declaration.type, 0) : declaration.type;
   const storedStatic = declaration.modifiers.includes("static") && !declaration.modifiers.includes("readonly");
@@ -109506,6 +109902,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       );
     }
     const multiselect = fieldType.name === "Set" || selection2 === "Multi";
+    assertNoElementSettings(fieldType, ownerClass, declaration, "lookup");
     return {
       ...common,
       kind: "lookup",
@@ -109540,9 +109937,11 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     }
     const multiselect = name === "Set" || selection2 === "Multi";
     if (enumId2 && multiselect) {
+      assertNoElementSettings(fieldType, ownerClass, declaration, "enum");
       return { ...common, kind: "enum", enumId: enumId2, multiselect: true };
     }
     if (entryType.name === "Dialogue" && multiselect) {
+      assertNoElementSettings(fieldType, ownerClass, declaration, "dialogue");
       return {
         ...common,
         kind: "dialogueLookup",
@@ -109567,7 +109966,8 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       entryType,
       entryId,
       id2,
-      declaringMemberId
+      declaringMemberId,
+      entrySettings
     );
     return {
       ...common,
@@ -109596,7 +109996,8 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       entryType,
       entryId,
       id2,
-      declaringMemberId
+      declaringMemberId,
+      entrySettings
     );
     return {
       ...common,
@@ -109657,6 +110058,12 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
     `Unsupported field type ${JSON.stringify(name)} on ${ownerClass.name}.${declaration.name}.`
   );
 }
+function assertNoElementSettings(fieldType, ownerClass, declaration, kind) {
+  if (!fieldType.arguments[0]?.annotations?.length) return;
+  throw new Error(
+    `Member ${ownerClass.name}.${declaration.name} is a multi-select ${kind}, which has no entry member for element settings. Remove the annotations before its element type.`
+  );
+}
 function inheritedMember(context, memberId) {
   if (memberId === null) return void 0;
   return context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
@@ -109756,7 +110163,7 @@ function overrideParentMemberId(context, memberId) {
   const overrides = member.modifiers.includes("override") || member.modifiers.includes("sealed");
   return overrides ? inheritedMemberId(context, ownerClass, member.name) : null;
 }
-function lowerCollectionEntry(context, ownerClass, entryType, entryId, parentMemberId, declaringMemberId) {
+function lowerCollectionEntry(context, ownerClass, entryType, entryId, parentMemberId, declaringMemberId, entrySettings) {
   const declared = declaredCollectionEntryType(context, declaringMemberId);
   const expected = declared === null ? null : resolveManifestTypeInDescendant(
     context,
@@ -109783,7 +110190,7 @@ function lowerCollectionEntry(context, ownerClass, entryType, entryId, parentMem
   context.entryTypesByEntryId.set(entryId, entryDeclarationType);
   if (context.loweredMembers.has(entryId)) return;
   const base = context.baseMembers.get(entryId);
-  if (base) {
+  if (base !== void 0 && entrySettings === "stored") {
     context.loweredMembers.set(base.id, {
       ...base,
       owner: { kind: "collectionEntry", parentMemberId }
@@ -109801,7 +110208,7 @@ function lowerCollectionEntry(context, ownerClass, entryType, entryId, parentMem
     name: "Item",
     type: entryDeclarationType,
     modifiers: [],
-    annotations: [],
+    annotations: entryDeclarationType.annotations ?? [],
     initializer: null,
     body: null,
     parameters: []
@@ -109814,18 +110221,89 @@ function lowerCollectionEntry(context, ownerClass, entryType, entryId, parentMem
     { kind: "collectionEntry", parentMemberId },
     base
   );
+  const lowered = lowerFieldMember(
+    context,
+    entryOwnerClass,
+    declaration,
+    entryId,
+    common,
+    base,
+    entrySettings
+  );
+  if (base !== void 0 && entryTarget(base) !== entryTarget(lowered)) {
+    throw new Error(
+      `Collection member ${ownerClass.name}.${parentMemberId} declares element type ${formatManifestType(entryDeclarationType)}, but its stored entry member is a ${base.kind} of another type. An existing collection's element type cannot change; declare a new member instead.`
+    );
+  }
   context.loweredMembers.set(
     entryId,
-    lowerFieldMember(
-      context,
-      entryOwnerClass,
-      declaration,
-      entryId,
-      common,
-      base
-    )
+    base === void 0 ? lowered : {
+      ...withEntrySettings(base, lowered),
+      owner: { kind: "collectionEntry", parentMemberId }
+    }
   );
 }
+function entryTarget(member) {
+  switch (member.kind) {
+    case "class":
+      return `class:${member.classId}`;
+    case "enum":
+      return `enum:${member.enumId}`;
+    case "generic":
+      return `generic:${member.genericParamId}`;
+    default:
+      return member.kind;
+  }
+}
+function withEntrySettings(base, lowered) {
+  switch (lowered.kind) {
+    case "string":
+      return base.kind === lowered.kind ? {
+        ...base,
+        localizable: lowered.localizable,
+        searchKey: lowered.searchKey
+      } : base;
+    case "int":
+      return base.kind === lowered.kind ? { ...base, min: lowered.min, max: lowered.max } : base;
+    case "float":
+      return base.kind === lowered.kind ? {
+        ...base,
+        min: lowered.min,
+        max: lowered.max,
+        decimalPoints: lowered.decimalPoints
+      } : base;
+    case "decimal":
+      return base.kind === lowered.kind ? {
+        ...base,
+        min: lowered.min,
+        max: lowered.max,
+        decimalPoints: lowered.decimalPoints
+      } : base;
+    case "list":
+      return base.kind === lowered.kind ? { ...base, listKind: lowered.listKind } : base;
+    case "enum":
+      return base.kind === lowered.kind ? { ...base, multiselect: lowered.multiselect } : base;
+    case "lookup":
+      return base.kind === lowered.kind ? {
+        ...base,
+        collectionMemberId: lowered.collectionMemberId,
+        collectionValueId: lowered.collectionValueId,
+        multiselect: lowered.multiselect
+      } : base;
+    case "dialogueLookup":
+      return base.kind === lowered.kind ? {
+        ...base,
+        dialogueGroupId: lowered.dialogueGroupId,
+        multiselect: lowered.multiselect
+      } : base;
+    case "sprite":
+      return base.kind === lowered.kind ? { ...base, templateId: lowered.templateId } : base;
+    case "audio":
+      return base.kind === lowered.kind ? { ...base, templateId: lowered.templateId } : base;
+    default:
+      return base;
+  }
+}
 function declaredCollectionEntryType(context, declaringMemberId) {
   const placement = context.sourceMembersById.get(declaringMemberId);
   if (placement === void 0) return null;
@@ -111065,7 +111543,8 @@ function lowerGenericArgument(context, ownerClass, type, memberId, genericParamI
         requiredTypeArgument(type, base.kind === "list" ? 0 : 1),
         base.entryMemberId,
         memberId,
-        memberId
+        memberId,
+        "stored"
       );
     }
     return;
@@ -111106,7 +111585,8 @@ function lowerGenericArgument(context, ownerClass, type, memberId, genericParamI
         storage: base?.storage ?? null,
         storageKey: base?.storageKey ?? null
       },
-      base
+      base,
+      "stored"
     )
   );
 }
@@ -111219,7 +111699,74 @@ function numberArgument(value, name) {
 }
 function storageValue(value, name) {
   const enumValue2 = contextualEnumArgument(value, name)?.toLowerCase();
-  return enumValue2 === "immutable" || enumValue2 === "save" || enumValue2 === "session" ? enumValue2 : null;
+  return enumValue2 === "immutable" || enumValue2 === "save" || enumValue2 === "session" || enumValue2 === "writable" ? enumValue2 : null;
+}
+function assertWritableStorageRules(context, ownerClass, declaration, inheritedId) {
+  const site = `${ownerClass.name}.${declaration.name}`;
+  const storage = annotation(declaration.annotations, "storage");
+  const declared = storage ? contextualEnumArgument(storage, "allowed")?.toLowerCase() : void 0;
+  if (declared === "writable" && declaration.modifiers.includes("static")) {
+    throw new Error(
+      `Static member ${site} cannot declare Writable storage: a static member has no parent to resolve it against. Declare Save or Session.`
+    );
+  }
+  if (inheritedId === null) return;
+  const ancestor = writableAncestor(context, inheritedId);
+  if (ancestor === null) return;
+  if (declared === "immutable") {
+    throw new Error(
+      `${site} cannot declare Immutable storage because it overrides ${ancestor}, which declares Writable. Declare Writable, Save, or Session, or omit @storage.`
+    );
+  }
+  if (declared === "inherit") {
+    throw new Error(
+      `${site} cannot declare Inherit storage because it overrides ${ancestor}, which declares Writable. Declare Writable, Save, or Session, or omit @storage.`
+    );
+  }
+}
+function writableAncestor(context, memberId) {
+  const memo = context.writableAncestors;
+  const chain = /* @__PURE__ */ new Set();
+  let currentId = memberId;
+  let found = null;
+  while (currentId !== null) {
+    const known = memo.get(currentId);
+    if (known !== void 0) {
+      found = known;
+      break;
+    }
+    if (chain.has(currentId)) break;
+    chain.add(currentId);
+    const step = storageChainStep(context, currentId);
+    if (step === null) break;
+    if (step.storage === "writable") {
+      found = step.label;
+      break;
+    }
+    currentId = step.overrideOf;
+  }
+  for (const id2 of chain) memo.set(id2, found);
+  return found;
+}
+function storageChainStep(context, memberId) {
+  const sourcePlacement = context.sourceMembersById.get(memberId);
+  if (sourcePlacement !== void 0) {
+    const { ownerClass, member } = sourcePlacement;
+    const storage = annotation(member.annotations, "storage");
+    return {
+      label: `${ownerClass.name}.${member.name}`,
+      storage: storage ? storageValue(storage, "allowed") : null,
+      overrideOf: member.modifiers.includes("override") || member.modifiers.includes("sealed") ? inheritedMemberId(context, ownerClass, member.name) : null
+    };
+  }
+  const persisted = context.baseMembers.get(memberId);
+  if (persisted === void 0) return null;
+  const ownerName = persisted.owner.kind === "classMember" ? context.baseClasses.get(persisted.owner.classId)?.name : void 0;
+  return {
+    label: ownerName === void 0 ? persisted.name : `${ownerName}.${persisted.name}`,
+    storage: persisted.storage,
+    overrideOf: persisted.overrideOf
+  };
 }
 function referenceIdArgument(value, name) {
   const raw = argument(value, name);
@@ -112199,6 +112746,7 @@ function lowerProjectSchemaV4(base, analysis, options = {}) {
     enumOptionsByName,
     loweredMembers: /* @__PURE__ */ new Map(),
     entryTypesByEntryId: /* @__PURE__ */ new Map(),
+    writableAncestors: /* @__PURE__ */ new Map(),
     placements: /* @__PURE__ */ new Map(),
     staticValueIdsBySymbol: staticValueIdsBySymbol3,
     settleInitializerReferences: createSchemaInitializerReferenceSettlerV4({
@@ -115274,6 +115822,8 @@ var init_root_value_paths = __esm({
 // src/project-source/packed-value-parity.ts
 function logicalValueBaseRecordsV4(records2) {
   let expanded = null;
+  const parentByPackedId = /* @__PURE__ */ new Map();
+  const rootByPackedId = /* @__PURE__ */ new Map();
   for (const [key, record6] of Object.entries(records2)) {
     if (record6.recordKind !== "value") continue;
     if (!isObjectRecord2(record6.data)) continue;
@@ -115285,6 +115835,12 @@ function logicalValueBaseRecordsV4(records2) {
       );
     }
     const decoded = decodePackedValueRow(authoredData);
+    for (const [parentId, childIds] of decoded.packedChildIdsByParentId) {
+      for (const childId of childIds) {
+        parentByPackedId.set(childId, parentId);
+        rootByPackedId.set(childId, record6.recordId);
+      }
+    }
     expanded ??= { ...records2 };
     expanded[key] = { ...record6, data: decoded.row };
     for (const child of decoded.children) {
@@ -115297,7 +115853,10 @@ function logicalValueBaseRecordsV4(records2) {
       };
     }
   }
-  return expanded ?? records2;
+  return {
+    records: expanded ?? records2,
+    residency: { parentByPackedId, rootByPackedId }
+  };
 }
 function foldCandidateValueRowsV4(args) {
   if (args.candidates.size === 0) return EMPTY_FOLD;
@@ -115309,7 +115868,11 @@ function foldCandidateValueRowsV4(args) {
     rows.push(row);
     inputById.set(valueId, row);
   }
-  const fold = foldPackedValueRows({ rows, document: args.schema });
+  const fold = foldPackedValueRows({
+    rows,
+    document: args.schema,
+    residency: args.residency
+  });
   if (fold.rootByFoldedId.size === 0) return EMPTY_FOLD;
   const adoptedRootIds = /* @__PURE__ */ new Set();
   for (const [childId, rootId] of fold.rootByFoldedId) {
@@ -116410,9 +116973,7 @@ function computeWorkspaceStatus(workspace, options) {
       binaryFiles: []
     };
   }
-  const loweringRecords = logicalValueBaseRecordsV4(
-    loweringBaseRecords(workspace.state.records)
-  );
+  const { records: loweringRecords, residency: packedResidency } = logicalValueBaseRecordsV4(loweringBaseRecords(workspace.state.records));
   const baseDocuments = schemaBaseDocuments(workspace);
   const staticMemberOwnershipRecoveries = [];
   const baseManifest = baseDocuments.length === 0 ? void 0 : documentsToProjectSchemaManifest(baseDocuments, {
@@ -116978,6 +117539,14 @@ function computeWorkspaceStatus(workspace, options) {
       workspace.config.projectId
     ),
     reconstructed: reconstructed3,
+    changes,
+    residency: packedResidency,
+    rewrittenValueIds: valueLowerRegistry.localizationConversionValueIds
+  });
+  writeLocalizationConversionRowsV4({
+    workspace,
+    rootByPackedId: packedResidency.rootByPackedId,
+    valueIds: valueLowerRegistry.localizationConversionValueIds,
     changes
   });
   reportPhase("packed-value-fold", "Checking initializers\u2026");
@@ -117612,7 +118181,7 @@ function applyPackedValueFoldV4(args) {
     candidates.set(record6.recordId, record6.fullData);
     const logicalBase = args.loweringRecords[key];
     const physicalBase = args.workspace.state.records[key];
-    if (logicalBase === void 0 || physicalBase === void 0 || physicalBase.conflictServerHash !== void 0 || isPendingId(record6.recordId) || !recordsSemanticallyEqual("value", record6.fullData, logicalBase.data)) {
+    if (logicalBase === void 0 || physicalBase === void 0 || physicalBase.conflictServerHash !== void 0 || isPendingId(record6.recordId) || args.rewrittenValueIds.has(record6.recordId) || !recordsSemanticallyEqual("value", record6.fullData, logicalBase.data)) {
       touchedValueIds.add(record6.recordId);
     }
   }
@@ -117620,6 +118189,7 @@ function applyPackedValueFoldV4(args) {
     candidates,
     base: args.loweringRecords,
     physicalBase: args.workspace.state.records,
+    residency: args.residency,
     touchedValueIds,
     projectId: args.workspace.config.projectId,
     schema: args.schema
@@ -117704,6 +118274,32 @@ function applyPackedValueFoldV4(args) {
     args.reconstructed.set(key, { ...record6, fullData: packedBody });
   }
 }
+function writeLocalizationConversionRowsV4(args) {
+  if (args.valueIds.size === 0) return;
+  const records2 = args.workspace.state.records;
+  const written = new Set(
+    args.changes.map(
+      (change) => recordStateKey(change.recordKind, change.recordId)
+    )
+  );
+  for (const valueId of args.valueIds) {
+    const rootId = args.rootByPackedId.get(valueId) ?? valueId;
+    const key = recordStateKey("value", rootId);
+    if (written.has(key)) continue;
+    const base = records2[key];
+    if (base === void 0 || !isObjectRecord2(base.data)) continue;
+    written.add(key);
+    args.changes.push(
+      recordUpsertChange({
+        base,
+        recordKind: "value",
+        recordId: base.recordId,
+        file: base.file ?? null,
+        nextData: base.data
+      })
+    );
+  }
+}
 function packedFoldSchemaV4(documents, base, projectId) {
   const seedEnvelope = { projectId, createdAt: 0, updatedAt: 0 };
   const completed = /* @__PURE__ */ new Map();
@@ -120257,6 +120853,7 @@ function createValueLowerRegistryV4(options = {}) {
     pendingContainerChildCounts: /* @__PURE__ */ new Map(),
     pendingLocalizedTexts: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: /* @__PURE__ */ new Map(),
+    localizationConversionValueIds: /* @__PURE__ */ new Set(),
     referenceObligations: [],
     initAuthoredRowIds: /* @__PURE__ */ new Map(),
     loweringFailures: [],
@@ -120376,6 +120973,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     pendingValues: registry.pendingValues,
     pendingContainerChildCounts: registry.pendingContainerChildCounts,
     pendingLocalizedTexts: registry.pendingLocalizedTexts,
+    localizationConversionValueIds: registry.localizationConversionValueIds,
     loweredMemberIdByValueId: /* @__PURE__ */ new Map(),
     storedClassSchemaMemberIds: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: registry.pendingBindingMembersByClassId,
@@ -123226,6 +123824,10 @@ function retainStoredValueSubgraph(context, valueId, source, visited, member, en
         `Localizable value ${valueId} has no existing localized-text link.`
       );
     }
+    if (pulledStringMemberIsPlain(context.state, owningMember.id)) {
+      context.localizationConversionValueIds.add(valueId);
+      return;
+    }
     const textState = context.state[`localized-text:${textId}`];
     if (!isObjectRecord2(textState?.data)) {
       throw new Error(`Localized text ${textId} was not pulled.`);
@@ -123976,6 +124578,10 @@ function lowerStringValue(context, member, expression, base, source) {
       `Localizable value ${String(base.id)} has no existing localized-text link.`
     );
   }
+  if (pulledStringMemberIsPlain(context.state, member.id)) {
+    context.localizationConversionValueIds.add(String(base.id));
+    return expression.value;
+  }
   return lowerLinkedLocalizedText(
     context,
     base.value,
@@ -123983,6 +124589,19 @@ function lowerStringValue(context, member, expression, base, source) {
     source
   );
 }
+function pulledStringMemberIsPlain(state, memberId) {
+  const visited = /* @__PURE__ */ new Set();
+  let id2 = memberId;
+  while (typeof id2 === "string" && !visited.has(id2)) {
+    visited.add(id2);
+    const data = state[`member:${id2}`]?.data;
+    if (!isObjectRecord2(data)) return false;
+    if (data.format !== void 0)
+      return data.format === 1 /* Plain */;
+    id2 = data.extendsMemberId;
+  }
+  return false;
+}
 function lowerLinkedLocalizedText(context, textId, value, source) {
   const textState = context.state[`localized-text:${textId}`];
   if (!isObjectRecord2(textState?.data)) {
@@ -127629,7 +128248,7 @@ var init_project_document_cache = __esm({
     init_src();
     init_project_documents();
     PROJECT_SOURCE_BUILD_CACHE_PATH = ".neo/build/project-source-analysis-v4.json";
-    PROJECT_SOURCE_BUILD_CACHE_REVISION = 1;
+    PROJECT_SOURCE_BUILD_CACHE_REVISION = 2;
     PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_PATH = ".neo/build/project-source-documents-v1.json";
     PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION = 1;
   }
@@ -138866,7 +139485,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.54.1",
+      cliVersion: "0.56.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -139208,8 +139827,8 @@ var init_registry2 = __esm({
       sdkDeclarations: {
         attributes: {
           enums: {
-            NeoStorage: ["Inherit", "Immutable", "Save", "Session"],
-            NeoAllowedStorage: ["Any", "Immutable", "Save", "Session"],
+            NeoStorage: ["Inherit", "Immutable", "Save", "Session", "Writable"],
+            NeoAllowedStorage: ["Any", "Immutable", "Save", "Session", "Writable"],
             NeoListKind: ["Ordered", "Unordered"],
             NeoDictionaryKeyKind: ["String", "Enum"],
             NeoClassVisibility: ["Visible", "Hidden"],
@@ -146687,7 +147306,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.54.1");
+    console.log("0.56.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {