@neocompose/cli 0.1.0 → 0.1.1

package/dist/neo.mjs

@@ -278,7 +278,40 @@ var init_project_db_response_types = __esm({
   }
 });
 
+// ../src/models/attributes/attribute-storage.ts
+function isAttributeStorage(value) {
+  if (typeof value !== "string") return false;
+  return ATTRIBUTE_STORAGE_VALUES.has(value);
+}
+function isEffectiveAttributeStorage(value) {
+  if (!isAttributeStorage(value)) return false;
+  return value !== "inherit" /* Inherit */;
+}
+var AttributeStorage, ATTRIBUTE_STORAGE_VALUES;
+var init_attribute_storage = __esm({
+  "../src/models/attributes/attribute-storage.ts"() {
+    "use strict";
+    AttributeStorage = /* @__PURE__ */ ((AttributeStorage3) => {
+      AttributeStorage3["Inherit"] = "inherit";
+      AttributeStorage3["Static"] = "static";
+      AttributeStorage3["Save"] = "save";
+      AttributeStorage3["Session"] = "session";
+      return AttributeStorage3;
+    })(AttributeStorage || {});
+    ATTRIBUTE_STORAGE_VALUES = new Set(
+      Object.values(AttributeStorage)
+    );
+  }
+});
+
 // ../src/models/project/project-root-attributes.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 projectRootAttributesInDisplayOrder(project) {
   return PROJECT_ROOTS.map((root) => ({
     root,
@@ -289,27 +322,28 @@ var PROJECT_ROOTS;
 var init_project_root_attributes = __esm({
   "../src/models/project/project-root-attributes.ts"() {
     "use strict";
+    init_attribute_storage();
     PROJECT_ROOTS = [
       {
         key: "Assets",
         choice: "assets",
         projectField: "rootAssetsAttributeId",
         label: "Assets",
-        writable: false
+        storage: "static" /* Static */
       },
       {
         key: "Save",
         choice: "save",
         projectField: "rootSaveFileAttributeId",
         label: "Save",
-        writable: true
+        storage: "save" /* Save */
       },
       {
         key: "Session",
         choice: "session",
         projectField: "rootSessionAttributeId",
         label: "Session",
-        writable: true
+        storage: "session" /* Session */
       }
     ];
   }
@@ -516,6 +550,29 @@ function readWorkspaceConfig(root) {
       `"${NEO_CONFIG_FILE}" is missing string field "apiBaseUrl".`
     );
   }
+  const profile = config.profile === "release" ? "release" : "editor";
+  const convexUrl = typeof config.convexUrl === "string" ? config.convexUrl : void 0;
+  if (typeof config.unityConfigPath === "string") {
+    if (config.projectId !== void 0) {
+      throw new Error(
+        `"${NEO_CONFIG_FILE}" sets "unityConfigPath", so "projectId" must be removed \u2014 the Unity config asset is the single source of truth.`
+      );
+    }
+    if (config.versionId !== void 0) {
+      throw new Error(
+        `"${NEO_CONFIG_FILE}" sets "unityConfigPath", so "versionId" must be removed \u2014 the Unity config asset is the single source of truth.`
+      );
+    }
+    const ids = readUnityConfigIds(root, config.unityConfigPath);
+    return {
+      apiBaseUrl: config.apiBaseUrl,
+      projectId: ids.projectId,
+      versionId: ids.versionId,
+      profile,
+      convexUrl,
+      unityConfigPath: config.unityConfigPath
+    };
+  }
   if (typeof config.projectId !== "string") {
     throw new Error(
       `"${NEO_CONFIG_FILE}" is missing string field "projectId".`
@@ -526,23 +583,79 @@ function readWorkspaceConfig(root) {
       `"${NEO_CONFIG_FILE}" is missing string field "versionId".`
     );
   }
-  const profile = config.profile === "release" ? "release" : "editor";
   return {
     apiBaseUrl: config.apiBaseUrl,
     projectId: config.projectId,
     versionId: config.versionId,
     profile,
-    convexUrl: typeof config.convexUrl === "string" ? config.convexUrl : void 0
+    convexUrl
   };
 }
 function writeWorkspaceConfig(root, config) {
+  let persisted = { ...config };
+  if (config.unityConfigPath !== void 0) {
+    const { projectId, versionId, ...rest } = persisted;
+    void projectId;
+    void versionId;
+    persisted = rest;
+    writeUnityConfigVersionId(root, config.unityConfigPath, config.versionId);
+  }
   writeFileSync2(
     join2(root, NEO_CONFIG_FILE),
-    `${JSON.stringify(config, null, 2)}
+    `${JSON.stringify(persisted, null, 2)}
 `,
     "utf8"
   );
 }
+function readUnityConfigIds(root, unityConfigPath) {
+  const assetPath = resolve(root, unityConfigPath);
+  if (!existsSync2(assetPath)) {
+    throw new Error(
+      `"unityConfigPath" in "${NEO_CONFIG_FILE}" points to "${assetPath}", which does not exist.`
+    );
+  }
+  const content = readFileSync2(assetPath, "utf8");
+  const projectId = matchUnityScalarField(content, "projectId");
+  if (projectId === null) {
+    throw new Error(
+      `Unity config asset "${assetPath}" has no "projectId" field.`
+    );
+  }
+  const versionId = matchUnityScalarField(content, "versionId");
+  if (versionId === null) {
+    throw new Error(
+      `Unity config asset "${assetPath}" has no "versionId" field.`
+    );
+  }
+  return { projectId, versionId };
+}
+function writeUnityConfigVersionId(root, unityConfigPath, versionId) {
+  const assetPath = resolve(root, unityConfigPath);
+  if (!existsSync2(assetPath)) {
+    throw new Error(
+      `"unityConfigPath" in "${NEO_CONFIG_FILE}" points to "${assetPath}", which does not exist.`
+    );
+  }
+  const content = readFileSync2(assetPath, "utf8");
+  const current = matchUnityScalarField(content, "versionId");
+  if (current === null) {
+    throw new Error(
+      `Unity config asset "${assetPath}" has no "versionId" field to update.`
+    );
+  }
+  if (current === versionId) return;
+  const updated = content.replace(
+    /^(\s*versionId:[ \t]*).*$/m,
+    `$1${versionId}`
+  );
+  writeFileSync2(assetPath, updated, "utf8");
+}
+function matchUnityScalarField(content, field) {
+  const match = new RegExp(`^\\s*${field}:[ \\t]*(\\S+)[ \\t]*$`, "m").exec(
+    content
+  );
+  return match === null ? null : match[1];
+}
 function readWorkspaceState(root) {
   const statePath = join2(root, NEO_STATE_DIR, NEO_STATE_FILE);
   if (!existsSync2(statePath)) {
@@ -713,6 +826,11 @@ function isNSTypeInfoAsset(value) {
   const t = value.type;
   return t === 11 /* Sprite */ || t === 12 /* Audio */;
 }
+function isNSTypeInfoVector(value) {
+  if (!isNSTypeInfoBase(value)) return false;
+  const t = value.type;
+  return t === 14 /* Vector2 */ || t === 15 /* Vector2Int */ || t === 16 /* Vector3 */ || t === 17 /* Vector3Int */;
+}
 function isNSTypeInfoUnknown(value) {
   const v = value;
   return typeof v === "object" && v !== null && v.type === NS_TYPE_UNKNOWN && typeof v.required === "boolean";
@@ -748,7 +866,7 @@ function isNSTypeInfoEnum(value) {
   return typeof v.enumId === "string" && v.enumId.length > 0;
 }
 function isNSTypeInfo(value) {
-  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoCustom(value) || isNSTypeInfoCollection(value) || isNSTypeInfoLookup(value) || isNSTypeInfoEnum(value);
+  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoCustom(value) || isNSTypeInfoCollection(value) || isNSTypeInfoLookup(value) || isNSTypeInfoEnum(value);
 }
 function isNSArgumentTypeInfo(value) {
   return isRequiredType(value, isNSArgumentTypeInfoUnsafe);
@@ -824,6 +942,59 @@ function isAttributeString(value) {
 function isAttributeFloatBase(value) {
   return asTypedAttributeBase(value, 4 /* Float */) !== null;
 }
+function hasExactKeys(value, keys) {
+  const actual = Object.keys(value);
+  if (actual.length !== keys.length) return false;
+  return keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function isFiniteNumberValue(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isVectorComponentValue(value, integer) {
+  if (!isFiniteNumberValue(value)) return false;
+  if (!integer) return true;
+  return Number.isInteger(value);
+}
+function isVector2ValueWithComponents(value, integer) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (!hasExactKeys(record, ["x", "y"])) return false;
+  return isVectorComponentValue(record.x, integer) && isVectorComponentValue(record.y, integer);
+}
+function isVector3ValueWithComponents(value, integer) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (!hasExactKeys(record, ["x", "y", "z"])) return false;
+  return isVectorComponentValue(record.x, integer) && isVectorComponentValue(record.y, integer) && isVectorComponentValue(record.z, integer);
+}
+function isVector2Value(value) {
+  return isVector2ValueWithComponents(value, false);
+}
+function isVector2IntValue(value) {
+  return isVector2ValueWithComponents(value, true);
+}
+function isVector3Value(value) {
+  return isVector3ValueWithComponents(value, false);
+}
+function isVector3IntValue(value) {
+  return isVector3ValueWithComponents(value, true);
+}
+function isAttributeVector2Base(value) {
+  return asTypedAttributeBase(value, 14 /* Vector2 */) !== null;
+}
+function isAttributeVector2IntBase(value) {
+  return asTypedAttributeBase(value, 15 /* Vector2Int */) !== null;
+}
+function isAttributeVector3Base(value) {
+  return asTypedAttributeBase(value, 16 /* Vector3 */) !== null;
+}
+function isAttributeVector3IntBase(value) {
+  return asTypedAttributeBase(value, 17 /* Vector3Int */) !== null;
+}
 function isAttributeDictionaryBase(value) {
   const v = asTypedAttributeBase(value, 5 /* Dictionary */);
   if (v === null) return false;
@@ -931,13 +1102,25 @@ function isAttributeFunctionBase(value) {
   }
   return true;
 }
+function attributeTypeSupportsStorage(type) {
+  if (type === 10 /* NSGetter */) return false;
+  return type !== 13 /* Function */;
+}
+function hasValidStorageField(v) {
+  if (v.storage === void 0) return true;
+  if (v.storage === null) return true;
+  if (!isAttributeStorage(v.storage)) return false;
+  if (typeof v.type !== "number") return false;
+  return attributeTypeSupportsStorage(v.type);
+}
 function isAttributeBase(value) {
   const v = value;
-  const matchesConcreteType = isAttributeNullBase(value) || isAttributeBoolBase(value) || isAttributeIntBase(value) || isAttributeStringBase(value) || isAttributeFloatBase(value) || isAttributeDictionaryBase(value) || isAttributeListBase(value) || isAttributeCustomBase(value) || isAttributeEnumBase(value) || isAttributeLookupBase(value) || isAttributeNSGetterBase(value) || isAttributeSpriteBase(value) || isAttributeAudioBase(value) || isAttributeFunctionBase(value);
+  const matchesConcreteType = isAttributeNullBase(value) || isAttributeBoolBase(value) || isAttributeIntBase(value) || isAttributeStringBase(value) || isAttributeFloatBase(value) || isAttributeDictionaryBase(value) || isAttributeListBase(value) || isAttributeCustomBase(value) || isAttributeEnumBase(value) || isAttributeLookupBase(value) || isAttributeNSGetterBase(value) || isAttributeSpriteBase(value) || isAttributeAudioBase(value) || isAttributeFunctionBase(value) || isAttributeVector2Base(value) || isAttributeVector2IntBase(value) || isAttributeVector3Base(value) || isAttributeVector3IntBase(value);
   if (!matchesConcreteType) return false;
   if (typeof v?.name !== "string") return false;
   if (typeof v.locked !== "boolean") return false;
   if (typeof v.required !== "boolean") return false;
+  if (!hasValidStorageField(v)) return false;
   if (v.system !== void 0 && v.system !== null) {
     return isSystemMetadata(v.system);
   }
@@ -959,6 +1142,7 @@ var init_attribute_types = __esm({
     "use strict";
     init_core();
     init_neoscript();
+    init_attribute_storage();
     AttributeType = /* @__PURE__ */ ((AttributeType9) => {
       AttributeType9[AttributeType9["Null"] = 0] = "Null";
       AttributeType9[AttributeType9["Bool"] = 1] = "Bool";
@@ -974,6 +1158,10 @@ var init_attribute_types = __esm({
       AttributeType9[AttributeType9["Sprite"] = 11] = "Sprite";
       AttributeType9[AttributeType9["Audio"] = 12] = "Audio";
       AttributeType9[AttributeType9["Function"] = 13] = "Function";
+      AttributeType9[AttributeType9["Vector2"] = 14] = "Vector2";
+      AttributeType9[AttributeType9["Vector2Int"] = 15] = "Vector2Int";
+      AttributeType9[AttributeType9["Vector3"] = 16] = "Vector3";
+      AttributeType9[AttributeType9["Vector3Int"] = 17] = "Vector3Int";
       return AttributeType9;
     })(AttributeType || {});
     FunctionAttributeNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -1010,7 +1198,7 @@ var init_attribute_types_db_response = __esm({
 // ../src/models/custom-types/custom-types.ts
 function isCustomTypeBase(value) {
   const v = value;
-  return typeof v?.name === "string" && isCustomTypeSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && typeof v?.hiddenInAttributeSelector === "boolean" && typeof v?.isAbstract === "boolean" && (v.system === void 0 || v.system === null || isSystemMetadata(v.system));
+  return typeof v?.name === "string" && isCustomTypeSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && typeof v?.hiddenInAttributeSelector === "boolean" && typeof v?.isAbstract === "boolean" && (v.allowedStorage === void 0 || v.allowedStorage === null || isEffectiveAttributeStorage(v.allowedStorage)) && (v.system === void 0 || v.system === null || isSystemMetadata(v.system));
 }
 function getCustomTypeSchemaKeyOrder(type) {
   const schemaKeys = Object.keys(type.schema);
@@ -1046,6 +1234,7 @@ var init_custom_types = __esm({
   "../src/models/custom-types/custom-types.ts"() {
     "use strict";
     init_core();
+    init_attribute_storage();
   }
 });
 
@@ -1645,6 +1834,165 @@ var init_build_default_attribute_value = __esm({
   }
 });
 
+// ../src/models/attributes/effective-storage.ts
+function declaredAttributeStorage(attributeId, attributes) {
+  const declared = walkExtendsAttributeChain(attributeId, attributes, (a) => {
+    const storage = a.storage;
+    return isAttributeStorage(storage) ? storage : void 0;
+  });
+  return declared ?? "inherit" /* Inherit */;
+}
+var EffectiveStorageResolver;
+var init_effective_storage = __esm({
+  "../src/models/attributes/effective-storage.ts"() {
+    "use strict";
+    init_attribute_storage();
+    init_attribute_types();
+    init_structural_narrow();
+    init_custom_types();
+    init_inheritance();
+    EffectiveStorageResolver = class {
+      constructor(ctx) {
+        this.ctx = ctx;
+        for (const attribute of ctx.attributes) {
+          this.attributeById.set(attribute.id, attribute);
+        }
+        this.buildParentEdges();
+      }
+      ctx;
+      attributeById = /* @__PURE__ */ new Map();
+      parentIdsByAttributeId = /* @__PURE__ */ new Map();
+      mergedSchemaByTypeId = /* @__PURE__ */ new Map();
+      effectiveByAttributeId = /* @__PURE__ */ new Map();
+      resolving = /* @__PURE__ */ new Set();
+      /** Declared storage of `attributeId`, resolved through the extends chain. */
+      declaredStorage(attributeId) {
+        return declaredAttributeStorage(attributeId, this.ctx.attributes);
+      }
+      /** Placement-parent attribute ids of `attributeId` (empty for roots). */
+      parentAttributeIds(attributeId) {
+        if (this.ctx.rootStorage.has(attributeId)) return [];
+        return this.parentIdsByAttributeId.get(attributeId) ?? [];
+      }
+      /**
+       * The set of effective storages of `attributeId` across every placement
+       * (specs/attribute-storage.md §2.3, generalized to the placement *graph*).
+       */
+      effectiveStorages(attributeId) {
+        const cached = this.effectiveByAttributeId.get(attributeId);
+        if (cached !== void 0) return cached;
+        if (this.resolving.has(attributeId)) {
+          return /* @__PURE__ */ new Set();
+        }
+        this.resolving.add(attributeId);
+        try {
+          const result = /* @__PURE__ */ new Set();
+          const rootStorage = this.ctx.rootStorage.get(attributeId);
+          if (rootStorage !== void 0) {
+            result.add(rootStorage);
+          } else {
+            const declared = this.declaredStorage(attributeId);
+            if (declared !== "inherit" /* Inherit */) {
+              result.add(declared);
+            } else {
+              for (const parentId of this.parentAttributeIds(attributeId)) {
+                for (const storage of this.effectiveStorages(parentId)) {
+                  result.add(storage);
+                }
+              }
+            }
+          }
+          this.effectiveByAttributeId.set(attributeId, result);
+          return result;
+        } finally {
+          this.resolving.delete(attributeId);
+        }
+      }
+      /**
+       * Effective storage for one concrete placement chain, ordered root-first
+       * (the project root at index 0, the target attribute last). Used when the
+       * caller knows the exact path (NeoScript member walks, value trees).
+       */
+      effectiveStorageForPath(attributeIdsRootToLeaf) {
+        for (let i = attributeIdsRootToLeaf.length - 1; i >= 0; i--) {
+          const attributeId = attributeIdsRootToLeaf[i];
+          const rootStorage = this.ctx.rootStorage.get(attributeId);
+          if (rootStorage !== void 0 && i === 0) return rootStorage;
+          const declared = this.declaredStorage(attributeId);
+          if (declared !== "inherit" /* Inherit */) return declared;
+        }
+        const rootId = attributeIdsRootToLeaf[0];
+        const anchored = rootId === void 0 ? void 0 : this.ctx.rootStorage.get(rootId);
+        if (anchored !== void 0) return anchored;
+        throw new Error(
+          `Storage path did not resolve: no attribute in the chain declares a storage class and the chain head "${rootId ?? "(empty)"}" is not a stamped project root.`
+        );
+      }
+      /** Custom type's merged (inheritance-resolved) schema, memoized. */
+      mergedSchema(typeId) {
+        const cached = this.mergedSchemaByTypeId.get(typeId);
+        if (cached !== void 0) return cached;
+        const chain = resolveInheritanceChain(typeId, this.ctx.types);
+        const merged = chain.length === 0 ? [] : mergeSchemas(chain);
+        this.mergedSchemaByTypeId.set(typeId, merged);
+        return merged;
+      }
+      /** Resolved per-type custom field — `customTypeId` through extends chain. */
+      resolvedCustomTypeId(attributeId) {
+        return walkExtendsAttributeChain(
+          attributeId,
+          this.ctx.attributes,
+          (a) => getOptionalString(a, "customTypeId")
+        );
+      }
+      /** Resolved `entryAttributeId` through the extends chain. */
+      resolvedEntryAttributeId(attributeId) {
+        return walkExtendsAttributeChain(
+          attributeId,
+          this.ctx.attributes,
+          (a) => getOptionalString(a, "entryAttributeId")
+        );
+      }
+      /** Resolved `collectionAttributeId` through the extends chain. */
+      resolvedCollectionAttributeId(attributeId) {
+        return walkExtendsAttributeChain(
+          attributeId,
+          this.ctx.attributes,
+          (a) => getOptionalString(a, "collectionAttributeId")
+        );
+      }
+      attribute(attributeId) {
+        return this.attributeById.get(attributeId);
+      }
+      buildParentEdges() {
+        const addEdge = (childId, parentId) => {
+          const existing = this.parentIdsByAttributeId.get(childId);
+          if (existing === void 0) {
+            this.parentIdsByAttributeId.set(childId, [parentId]);
+            return;
+          }
+          if (!existing.includes(parentId)) existing.push(parentId);
+        };
+        for (const attribute of this.ctx.attributes) {
+          if (attribute.type === 7 /* Custom */) {
+            const typeId = this.resolvedCustomTypeId(attribute.id);
+            if (typeId !== void 0) {
+              for (const entry of this.mergedSchema(typeId)) {
+                addEdge(entry.attributeId, attribute.id);
+              }
+            }
+            continue;
+          }
+          if (attribute.type === 6 /* List */ || attribute.type === 5 /* Dictionary */) {
+            const entryId = this.resolvedEntryAttributeId(attribute.id);
+            if (entryId !== void 0) addEdge(entryId, attribute.id);
+          }
+        }
+      }
+    };
+  }
+});
+
 // ../src/models/attributes/value-responses.ts
 var init_value_responses = __esm({
   "../src/models/attributes/value-responses.ts"() {
@@ -1678,9 +2026,11 @@ var init_delete_attribute_response = __esm({
 var init_attributes = __esm({
   "../src/models/attributes/index.ts"() {
     "use strict";
+    init_attribute_storage();
     init_attribute_types();
     init_attribute_types_db_response();
     init_build_default_attribute_value();
+    init_effective_storage();
     init_value_responses();
     init_edit_attribute_props();
     init_delete_attribute_response();
@@ -1747,6 +2097,7 @@ var init_localization_types = __esm({
 var init_localization_export = __esm({
   "../src/models/localization/localization-export.ts"() {
     "use strict";
+    init_localization_types();
   }
 });
 
@@ -2102,7 +2453,11 @@ var init_projection = __esm({
       NSGetter: 10,
       Sprite: 11,
       Audio: 12,
-      Function: 13
+      Function: 13,
+      Vector2: 14,
+      Vector2Int: 15,
+      Vector3: 16,
+      Vector3Int: 17
     };
     ATTRIBUTE_CLASS_BY_TYPE = {
       [ATTRIBUTE_TYPE.Null]: "NeoNull",
@@ -2118,7 +2473,11 @@ var init_projection = __esm({
       [ATTRIBUTE_TYPE.NSGetter]: "NeoGetter",
       [ATTRIBUTE_TYPE.Sprite]: "NeoSprite",
       [ATTRIBUTE_TYPE.Audio]: "NeoAudio",
-      [ATTRIBUTE_TYPE.Function]: "NeoFunction"
+      [ATTRIBUTE_TYPE.Function]: "NeoFunction",
+      [ATTRIBUTE_TYPE.Vector2]: "NeoVector2",
+      [ATTRIBUTE_TYPE.Vector2Int]: "NeoVector2Int",
+      [ATTRIBUTE_TYPE.Vector3]: "NeoVector3",
+      [ATTRIBUTE_TYPE.Vector3Int]: "NeoVector3Int"
     };
     ATTRIBUTE_TYPE_BY_CLASS = new Map(
       Object.entries(ATTRIBUTE_CLASS_BY_TYPE).map(([type, name]) => [
@@ -2836,6 +3195,18 @@ function reconstructTypeFile(parsed, typeIdsByName, enumIdsByName, baseRecords,
   data.name = namedString(marker, "Name", parsed.file) ?? declaration.name;
   data.isAbstract = declaration.isAbstract;
   data.hiddenInAttributeSelector = namedBoolean(marker, "Hidden", parsed.file) ?? false;
+  const allowedStorage = namedString(marker, "AllowedStorage", parsed.file);
+  if (allowedStorage !== void 0) {
+    if (allowedStorage !== "static" && allowedStorage !== "save" && allowedStorage !== "session") {
+      throw new SchemaParseError(
+        `AllowedStorage must be "static", "save", or "session"; found "${allowedStorage}".`,
+        parsed.file,
+        marker.line,
+        marker.column
+      );
+    }
+    data.allowedStorage = allowedStorage;
+  }
   const extendsTypeIdArg = namedString(marker, "ExtendsTypeId", parsed.file);
   if (extendsTypeIdArg !== void 0) {
     data.extendsTypeId = extendsTypeIdArg;
@@ -2959,6 +3330,18 @@ function reconstructProperty(file, property, typeIdsByName, enumIdsByName, baseR
   data.name = namedString(marker, "Name", file) ?? key;
   data.required = !property.nullable;
   data.locked = namedBoolean(marker, "Locked", file) ?? false;
+  const storage = namedString(marker, "Storage", file);
+  if (storage !== void 0) {
+    if (storage !== "static" && storage !== "save" && storage !== "session") {
+      throw new SchemaParseError(
+        `Storage must be "static", "save", or "session"; found "${storage}".`,
+        file,
+        marker.line,
+        marker.column
+      );
+    }
+    data.storage = storage;
+  }
   const extendsId = namedString(marker, "ExtendsId", file);
   if (extendsId !== void 0) data.extendsAttributeId = extendsId;
   const defaultJson = parseJsonArg(marker, "DefaultJson", file);
@@ -2990,6 +3373,11 @@ function reconstructProperty(file, property, typeIdsByName, enumIdsByName, baseR
       if (localizable !== void 0) data.localizable = localizable;
       break;
     }
+    case ATTRIBUTE_TYPE.Vector2:
+    case ATTRIBUTE_TYPE.Vector2Int:
+    case ATTRIBUTE_TYPE.Vector3:
+    case ATTRIBUTE_TYPE.Vector3Int:
+      break;
     case ATTRIBUTE_TYPE.Dictionary:
     case ATTRIBUTE_TYPE.List: {
       const entryChainJson = parseJsonArg(marker, "EntryChainJson", file);
@@ -3275,6 +3663,14 @@ function shapeToTrivialFields(shape, typeIdsByName, enumIdsByName, property, fil
       return { type: ATTRIBUTE_TYPE.String };
     case "float":
       return { type: ATTRIBUTE_TYPE.Float };
+    case "NeoVector2":
+      return { type: ATTRIBUTE_TYPE.Vector2 };
+    case "NeoVector2Int":
+      return { type: ATTRIBUTE_TYPE.Vector2Int };
+    case "NeoVector3":
+      return { type: ATTRIBUTE_TYPE.Vector3 };
+    case "NeoVector3Int":
+      return { type: ATTRIBUTE_TYPE.Vector3Int };
     case "IReadOnlyList":
       return { type: ATTRIBUTE_TYPE.List };
     case "IReadOnlyDictionary":
@@ -3686,6 +4082,12 @@ function emitTypeFile(context, typeRecord, warnings, reachableAttributeIds) {
     delete remaining.hiddenInAttributeSelector;
     if (data.hiddenInAttributeSelector) args.push("Hidden = true");
   }
+  if (typeof data.allowedStorage === "string") {
+    delete remaining.allowedStorage;
+    args.push(`AllowedStorage = ${csString(data.allowedStorage)}`);
+  } else if (data.allowedStorage === null) {
+    delete remaining.allowedStorage;
+  }
   const modifier = data.isAbstract === true ? "abstract" : "sealed";
   if (typeof data.isAbstract === "boolean") delete remaining.isAbstract;
   const schema = isObjectRecord2(data.schema) ? data.schema : {};
@@ -3822,6 +4224,12 @@ function emitProperty(context, schemaKey, attributeRecord, memberNames, warnings
     delete remaining.locked;
     if (data.locked) args.push("Locked = true");
   }
+  if (typeof data.storage === "string" && data.storage !== "inherit") {
+    delete remaining.storage;
+    args.push(`Storage = ${csString(data.storage)}`);
+  } else if (data.storage === "inherit") {
+    delete remaining.storage;
+  }
   const required = data.required === true;
   if (typeof data.required === "boolean") delete remaining.required;
   let csType = "object";
@@ -3865,6 +4273,18 @@ function emitProperty(context, schemaKey, attributeRecord, memberNames, warnings
         args.push(`Localizable = ${data.localizable ? "true" : "false"}`);
       }
       break;
+    case ATTRIBUTE_TYPE.Vector2:
+      csType = "NeoVector2";
+      break;
+    case ATTRIBUTE_TYPE.Vector2Int:
+      csType = "NeoVector2Int";
+      break;
+    case ATTRIBUTE_TYPE.Vector3:
+      csType = "NeoVector3";
+      break;
+    case ATTRIBUTE_TYPE.Vector3Int:
+      csType = "NeoVector3Int";
+      break;
     case ATTRIBUTE_TYPE.Dictionary:
     case ATTRIBUTE_TYPE.List: {
       const entryAttributeId = data.entryAttributeId;
@@ -4052,6 +4472,14 @@ function renderEntryChainType(context, chain, index) {
       return "string";
     case ATTRIBUTE_TYPE.Float:
       return "float";
+    case ATTRIBUTE_TYPE.Vector2:
+      return "NeoVector2";
+    case ATTRIBUTE_TYPE.Vector2Int:
+      return "NeoVector2Int";
+    case ATTRIBUTE_TYPE.Vector3:
+      return "NeoVector3";
+    case ATTRIBUTE_TYPE.Vector3Int:
+      return "NeoVector3Int";
     case ATTRIBUTE_TYPE.Dictionary:
       return `IReadOnlyDictionary<string, ${renderEntryChainType(context, chain, index + 1)}>`;
     case ATTRIBUTE_TYPE.List:
@@ -6129,6 +6557,43 @@ function resolveAssetMemberType(receiverType, memberName) {
   }
   return null;
 }
+function resolveVectorMemberType(receiverType, memberName) {
+  const componentType = receiverType.type === 15 /* Vector2Int */ || receiverType.type === 17 /* Vector3Int */ ? 2 /* Int */ : receiverType.type === 14 /* Vector2 */ || receiverType.type === 16 /* Vector3 */ ? 4 /* Float */ : null;
+  if (componentType === null) return null;
+  if (memberName === "x" || memberName === "y") {
+    return { type: componentType, required: true };
+  }
+  if (memberName === "z" && (receiverType.type === 16 /* Vector3 */ || receiverType.type === 17 /* Vector3Int */)) {
+    return { type: componentType, required: true };
+  }
+  return null;
+}
+function vectorTypeForConstructorName(name) {
+  switch (name) {
+    case "Vector2":
+      return 14 /* Vector2 */;
+    case "Vector2Int":
+      return 15 /* Vector2Int */;
+    case "Vector3":
+      return 16 /* Vector3 */;
+    case "Vector3Int":
+      return 17 /* Vector3Int */;
+    default:
+      return null;
+  }
+}
+function vectorComponentCount(type) {
+  if (type === 14 /* Vector2 */ || type === 15 /* Vector2Int */) {
+    return 2;
+  }
+  return 3;
+}
+function vectorComponentType(type) {
+  if (type === 15 /* Vector2Int */ || type === 17 /* Vector3Int */) {
+    return 2 /* Int */;
+  }
+  return 4 /* Float */;
+}
 function describeType(t) {
   const opt = t.required ? "" : "?";
   switch (t.type) {
@@ -6148,6 +6613,14 @@ function describeType(t) {
       return `SpriteInfo${opt}`;
     case 12 /* Audio */:
       return `AudioClipInfo${opt}`;
+    case 14 /* Vector2 */:
+      return `Vector2${opt}`;
+    case 15 /* Vector2Int */:
+      return `Vector2Int${opt}`;
+    case 16 /* Vector3 */:
+      return `Vector3${opt}`;
+    case 17 /* Vector3Int */:
+      return `Vector3Int${opt}`;
     case 7 /* Custom */:
       return `Custom<${t.typeId}>${opt}`;
     case 8 /* Enum */:
@@ -6697,6 +7170,9 @@ var init_resolver = __esm({
        * (bool for Where/Find, inferred for Select).
        */
       expectedReturnStack = [];
+      /** Lazy effective-storage machinery for writability classification. */
+      storageResolver = null;
+      rootStorageByAttributeId = null;
       compile(body) {
         const scope = new Scope(null);
         scope.define({
@@ -6851,8 +7327,9 @@ var init_resolver = __esm({
           }
           case "return": {
             const expectedReturn = this.currentExpectedReturn();
+            const inActionBody = this.ctx.mode === "action" /* Action */ && this.lambdaDepth === 0;
             if (stmt.expr === null) {
-              if (this.ctx.mode === "action" /* Action */) {
+              if (inActionBody) {
                 return {
                   type: "return" /* return */,
                   pointer: null
@@ -6870,7 +7347,7 @@ var init_resolver = __esm({
               };
             }
             const resolved = this.resolveExpr(stmt.expr, scope, expectedReturn);
-            if (this.ctx.mode === "action" /* Action */) {
+            if (inActionBody) {
               if (resolved.type.type !== 0 /* Null */) {
                 throw new CompileError(
                   `Action functions can only return null; got ${describeType(resolved.type)}`,
@@ -7444,70 +7921,153 @@ var init_resolver = __esm({
             pos
           );
         }
-        if (path === "root.Save" || path?.startsWith("root.Save.")) {
-          return "save" /* Save */;
-        }
-        if (path === "root.Session" || path?.startsWith("root.Session.")) {
-          return "session" /* Session */;
-        }
-        if (path === "root.Assets" || path?.startsWith("root.Assets.")) {
-          const lookupWritability = this.rootAssetsPathCrossesWritableLookup(
-            expr,
-            scope
+        const rooted = this.resolveRootedTargetStorage(expr, scope);
+        if (rooted !== null) {
+          if (rooted.storage === "save" /* Save */) {
+            return rooted.reRootedFromStatic ? "assetToSaveLookup" /* AssetToSaveLookup */ : "save" /* Save */;
+          }
+          if (rooted.storage === "session" /* Session */) {
+            return rooted.reRootedFromStatic ? "assetToSessionLookup" /* AssetToSessionLookup */ : "session" /* Session */;
+          }
+          throw new CompileError(
+            `Cannot assign to '${path}' because its effective storage is static.`,
+            pos
           );
-          if (lookupWritability) return lookupWritability;
+        }
+        const declared = this.declaredStorageForMemberTarget(expr, scope, pos);
+        if (declared === "static" /* Static */) {
           throw new CompileError(
-            `Cannot assign to '${path}' because asset values are read-only.`,
+            `Cannot assign to '${path}' because its effective storage is static.`,
             pos
           );
         }
+        if (declared === "session" /* Session */) return "session" /* Session */;
         return "save" /* Save */;
       }
-      validateNonGetterAssignmentTarget(expr, scope, pos) {
-        if (expr.kind !== "member") return;
+      /**
+       * Placement-based storage resolution for an assignment target rooted at a
+       * `root.<Member>` path (specs/attribute-storage.md §5.1). Returns null for
+       * targets not rooted at `root` — their placement is runtime-determined.
+       *
+       * Walks the member/index chain root-first, tracking the effective storage
+       * context: each hop's declared storage (resolved through the extends
+       * chain) replaces the context; Lookup hops on a Static context re-root the
+       * context at the target collection's effective storage and mark the
+       * `AssetTo*Lookup` classification (§2.4 / legacy
+       * `rootAssetsPathCrossesWritableLookup` semantics).
+       */
+      resolveRootedTargetStorage(expr, scope) {
+        if (expr.kind === "index") {
+          const receiver = this.resolveRootedTargetStorage(expr.receiver, scope);
+          if (receiver === null) return null;
+          let storage2 = receiver.storage;
+          let entryAttributeId = null;
+          if (receiver.attributeId !== null) {
+            const storageResolver2 = this.getStorageResolver();
+            const directEntryId = storageResolver2.resolvedEntryAttributeId(
+              receiver.attributeId
+            );
+            const lookupCollectionId = directEntryId === void 0 ? storageResolver2.resolvedCollectionAttributeId(
+              receiver.attributeId
+            ) : void 0;
+            const entryId = directEntryId ?? (lookupCollectionId === void 0 ? void 0 : storageResolver2.resolvedEntryAttributeId(lookupCollectionId));
+            if (entryId !== void 0) {
+              entryAttributeId = entryId;
+              const declared2 = storageResolver2.declaredStorage(entryId);
+              if (declared2 !== "inherit" /* Inherit */) storage2 = declared2;
+            }
+          }
+          return {
+            storage: storage2,
+            reRootedFromStatic: receiver.reRootedFromStatic,
+            attributeId: entryAttributeId
+          };
+        }
+        if (expr.kind !== "member") return null;
+        if (expr.receiver.kind === "ident" && expr.receiver.name === "root") {
+          const rootId = this.rootAttributeIdForMember(expr.name);
+          if (rootId === null) return null;
+          const storage2 = this.getRootStorageMap().get(rootId);
+          if (storage2 === void 0) return null;
+          return { storage: storage2, reRootedFromStatic: false, attributeId: rootId };
+        }
+        const parent = this.resolveRootedTargetStorage(expr.receiver, scope);
+        if (parent === null) return null;
         const attr = this.resolveMemberAttribute(
           expr.receiver,
           expr.name,
           scope,
-          pos
+          expr.pos
         );
-        if (attr?.type !== 10 /* NSGetter */) return;
-        throw new CompileError(
-          `Cannot assign to getter attribute '${attr.name}' because getter attributes are read-only.`,
-          pos
+        if (attr === null) {
+          return {
+            storage: parent.storage,
+            reRootedFromStatic: parent.reRootedFromStatic,
+            attributeId: null
+          };
+        }
+        const storageResolver = this.getStorageResolver();
+        let storage = parent.storage;
+        const declared = storageResolver.declaredStorage(attr.id);
+        if (declared !== "inherit" /* Inherit */) storage = declared;
+        let reRootedFromStatic = parent.reRootedFromStatic;
+        if (storage === "static" /* Static */ && isAttributeLookupBase(attr)) {
+          const collectionId = storageResolver.resolvedCollectionAttributeId(
+            attr.id
+          );
+          if (collectionId !== void 0) {
+            const targetStorage = this.lookupTargetStorage(collectionId);
+            if (targetStorage === "save" /* Save */ || targetStorage === "session" /* Session */) {
+              storage = targetStorage;
+              reRootedFromStatic = true;
+            }
+          }
+        }
+        return { storage, reRootedFromStatic, attributeId: attr.id };
+      }
+      /**
+       * Effective storage of a lookup's target collection across its placements.
+       * Save wins over Session when a collection is placed in both (mirrors the
+       * legacy save-root-first `attributeBelongsToRoot` check order).
+       */
+      lookupTargetStorage(collectionAttributeId) {
+        const set = this.getStorageResolver().effectiveStorages(
+          collectionAttributeId
         );
+        if (set.has("save" /* Save */)) return "save" /* Save */;
+        if (set.has("session" /* Session */)) return "session" /* Session */;
+        if (set.has("static" /* Static */)) return "static" /* Static */;
+        return null;
       }
-      rootAssetsPathCrossesWritableLookup(expr, scope) {
-        if (expr.kind === "index") {
-          return this.rootAssetsPathCrossesWritableLookup(expr.receiver, scope);
-        }
-        if (expr.kind !== "member") return null;
-        const receiverLookup = this.rootAssetsPathCrossesWritableLookup(
+      /**
+       * Declared storage (through the extends chain) of the final member
+       * attribute of a non-rooted assignment target, or `Inherit` when the
+       * target is not a member access / cannot be resolved.
+       */
+      declaredStorageForMemberTarget(expr, scope, pos) {
+        if (expr.kind !== "member") return "inherit" /* Inherit */;
+        const attr = this.resolveMemberAttribute(
           expr.receiver,
-          scope
+          expr.name,
+          scope,
+          pos
         );
-        if (receiverLookup) return receiverLookup;
+        if (attr === null) return "inherit" /* Inherit */;
+        return this.getStorageResolver().declaredStorage(attr.id);
+      }
+      validateNonGetterAssignmentTarget(expr, scope, pos) {
+        if (expr.kind !== "member") return;
         const attr = this.resolveMemberAttribute(
           expr.receiver,
           expr.name,
           scope,
-          expr.pos
+          pos
+        );
+        if (attr?.type !== 10 /* NSGetter */) return;
+        throw new CompileError(
+          `Cannot assign to getter attribute '${attr.name}' because getter attributes are read-only.`,
+          pos
         );
-        if (!attr) return null;
-        if (!isAttributeLookupBase(attr)) return null;
-        if (this.attributeBelongsToRoot(
-          this.ctx.project.rootSaveFileAttributeId,
-          attr.collectionAttributeId
-        )) {
-          return "assetToSaveLookup" /* AssetToSaveLookup */;
-        }
-        if (this.attributeBelongsToRoot(
-          this.ctx.project.rootSessionAttributeId,
-          attr.collectionAttributeId
-        )) {
-          return "assetToSessionLookup" /* AssetToSessionLookup */;
-        }
-        return null;
       }
       resolveMemberAttribute(receiverAst, name, scope, pos) {
         const receiver = this.resolveExpr(receiverAst, scope);
@@ -7529,45 +8089,28 @@ var init_resolver = __esm({
         if (!attributeId) return null;
         return this.ctx.attributes.find((a) => a.id === attributeId) ?? null;
       }
-      attributeBelongsToRoot(rootAttributeId, targetId) {
-        const visited = /* @__PURE__ */ new Set();
-        const stack = [rootAttributeId];
-        while (stack.length > 0) {
-          const attrId = stack.pop();
-          if (!attrId) continue;
-          if (attrId === targetId) return true;
-          if (visited.has(attrId)) continue;
-          visited.add(attrId);
-          const attr = this.ctx.attributes.find((a) => a.id === attrId);
-          if (!attr) continue;
-          if (isAttributeCustomBase(attr)) {
-            const customType = this.ctx.types.find(
-              (t) => t.id === attr.customTypeId
-            );
-            if (!customType) continue;
-            for (const entry of mergeSchemas(
-              resolveInheritanceChain(customType.id, this.ctx.types)
-            )) {
-              if (entry.attributeId !== null) stack.push(entry.attributeId);
-            }
-            continue;
-          }
-          if (isAttributeListBase(attr) || isAttributeDictionaryBase(attr)) {
-            stack.push(attr.entryAttributeId);
-            continue;
-          }
-          if (isAttributeLookupBase(attr)) {
-            stack.push(attr.collectionAttributeId);
-          }
-        }
-        return false;
-      }
       rootAttributeIdForMember(name) {
         const root = projectRootAttributesInDisplayOrder(this.ctx.project).find(
           (entry) => entry.root.key === name
         );
         return root?.attributeId ?? null;
       }
+      getRootStorageMap() {
+        if (this.rootStorageByAttributeId === null) {
+          this.rootStorageByAttributeId = buildRootStorageMap(this.ctx.project);
+        }
+        return this.rootStorageByAttributeId;
+      }
+      getStorageResolver() {
+        if (this.storageResolver === null) {
+          this.storageResolver = new EffectiveStorageResolver({
+            attributes: this.ctx.attributes,
+            types: this.ctx.types,
+            rootStorage: this.getRootStorageMap()
+          });
+        }
+        return this.storageResolver;
+      }
       invalidateNarrowingForAssignment(target, scope) {
         const path = canonicalPath(target);
         if (!path) return;
@@ -7749,6 +8292,20 @@ var init_resolver = __esm({
             type: optional ? withRequired(memberType, false) : memberType
           };
         }
+        const vectorMemberType = resolveVectorMemberType(receiver.type, name);
+        if (vectorMemberType !== null) {
+          return {
+            pointer: {
+              type: "keyOf" /* keyOf */,
+              keyOf: {
+                pointer: receiver.pointer,
+                key: stringPointer(name)
+              },
+              ...optional ? { optional: true } : {}
+            },
+            type: optional ? withRequired(vectorMemberType, false) : vectorMemberType
+          };
+        }
         if (receiver.type.type === 7 /* Custom */) {
           const typeId = receiver.type.typeId;
           if (typeId === ROOT_TYPE_ID) {
@@ -8202,6 +8759,10 @@ var init_resolver = __esm({
         );
       }
       resolveGlobalCall(name, args, scope, pos) {
+        const vectorType = vectorTypeForConstructorName(name);
+        if (vectorType !== null) {
+          return this.resolveVectorConstructorCall(vectorType, args, scope, pos);
+        }
         const functionType = name === "VisitCount" ? "visitCount" /* visitCount */ : name === "HasVisited" ? "hasVisited" /* hasVisited */ : null;
         if (!functionType) {
           throw new CompileError(`Unknown function '${name}'`, pos);
@@ -8230,20 +8791,53 @@ var init_resolver = __esm({
           type: functionType === "visitCount" /* visitCount */ ? { type: 2 /* Int */, required: true } : { type: 1 /* Bool */, required: true }
         };
       }
-      resolveCollectionMutationStatement(expr, scope, pos) {
-        const callee = expr.callee;
-        if (callee.kind !== "member") {
+      resolveVectorConstructorCall(vectorType, args, scope, pos) {
+        const expectedCount = vectorComponentCount(vectorType);
+        if (args.length !== expectedCount) {
           throw new CompileError(
-            "Collection mutation calls must use member-call form.",
+            `${AttributeType[vectorType]} takes ${expectedCount} numeric arguments, got ${args.length}`,
             pos
           );
         }
-        const receiver = this.resolveExpr(callee.receiver, scope);
-        if (receiver.type.type !== 6 /* List */ && receiver.type.type !== 5 /* Dictionary */ && receiver.type.type !== 9 /* Lookup */) {
-          throw new CompileError(
-            `Cannot call ${callee.name} on ${describeType(receiver.type)}; expected list, dictionary, or lookup set.`,
-            pos
-          );
+        const scalarType = vectorComponentType(vectorType);
+        const expectedType = { type: scalarType, required: true };
+        const resolved = args.map((arg) => this.resolveExpr(arg, scope));
+        for (const arg of resolved) {
+          if (!isAssignable(arg.type, expectedType, this.ctx.types)) {
+            throw new CompileError(
+              `${AttributeType[vectorType]} component must be ${describeType(expectedType)}; got ${describeType(arg.type)}`,
+              pos
+            );
+          }
+        }
+        return {
+          pointer: {
+            type: "function" /* function */,
+            function: {
+              type: "vectorConstructor" /* vectorConstructor */,
+              info: {
+                vectorType,
+                componentPointers: resolved.map((arg) => arg.pointer)
+              }
+            }
+          },
+          type: { type: vectorType, required: true }
+        };
+      }
+      resolveCollectionMutationStatement(expr, scope, pos) {
+        const callee = expr.callee;
+        if (callee.kind !== "member") {
+          throw new CompileError(
+            "Collection mutation calls must use member-call form.",
+            pos
+          );
+        }
+        const receiver = this.resolveExpr(callee.receiver, scope);
+        if (receiver.type.type !== 6 /* List */ && receiver.type.type !== 5 /* Dictionary */ && receiver.type.type !== 9 /* Lookup */) {
+          throw new CompileError(
+            `Cannot call ${callee.name} on ${describeType(receiver.type)}; expected list, dictionary, or lookup set.`,
+            pos
+          );
         }
         const localMutation = localCollectionMutationTargetEntry(
           callee.receiver,
@@ -8618,6 +9212,18 @@ var init_resolver = __esm({
                 required: t.required
               };
             }
+            if (t.name === "Vector2") {
+              return { type: 14 /* Vector2 */, required: t.required };
+            }
+            if (t.name === "Vector2Int") {
+              return { type: 15 /* Vector2Int */, required: t.required };
+            }
+            if (t.name === "Vector3") {
+              return { type: 16 /* Vector3 */, required: t.required };
+            }
+            if (t.name === "Vector3Int") {
+              return { type: 17 /* Vector3Int */, required: t.required };
+            }
             const customType = this.ctx.types.find((ct) => ct.name === t.name);
             if (customType) {
               return {
@@ -8682,6 +9288,14 @@ var init_resolver = __esm({
             return { type: 11 /* Sprite */, required };
           case 12 /* Audio */:
             return { type: 12 /* Audio */, required };
+          case 14 /* Vector2 */:
+            return { type: 14 /* Vector2 */, required };
+          case 15 /* Vector2Int */:
+            return { type: 15 /* Vector2Int */, required };
+          case 16 /* Vector3 */:
+            return { type: 16 /* Vector3 */, required };
+          case 17 /* Vector3Int */:
+            return { type: 17 /* Vector3Int */, required };
           case 7 /* Custom */:
             if (!isAttributeCustomBase(attr)) {
               throw new CompileError(
@@ -9022,6 +9636,16 @@ ${status.parseErrors.map((error) => `  ${error.message}`).join("\n")}`
         action: compileMigrationAction(status, change.nextData)
       };
     }
+    if (change.recordKind === "attribute" && change.nextData.type === 10 && typeof change.nextData.code === "string" && change.nextData.code.trim().length > 0) {
+      change.nextData = {
+        ...change.nextData,
+        getter: await compileAttributeGetter(
+          workspace,
+          status,
+          change.nextData
+        )
+      };
+    }
     if (change.kind === "create") {
       change.nextData = {
         ...change.nextData,
@@ -9231,6 +9855,35 @@ function rewriteFilesFromState(workspace) {
     workspace.state.records[key] = nextState;
   }
 }
+async function compileAttributeGetter(workspace, status, attributeData) {
+  const types = [];
+  const attributes = [];
+  const enums = [];
+  for (const record of status.reconstructed.values()) {
+    if (record.recordKind === "type") types.push(record.fullData);
+    else if (record.recordKind === "attribute")
+      attributes.push(record.fullData);
+    else if (record.recordKind === "enum") enums.push(record.fullData);
+  }
+  const attributeId = attributeData.id;
+  const thisType = types.find((type) => {
+    const schema = type.schema;
+    return typeof schema === "object" && schema !== null && Object.values(schema).includes(attributeId);
+  }) ?? null;
+  const { raw } = await fetchProjectDocument(workspace);
+  if (typeof raw.project !== "object" || raw.project === null) {
+    throw new Error("Cannot compile getter: project record is unavailable.");
+  }
+  return compileNSGetter(String(attributeData.code), {
+    project: raw.project,
+    attributes,
+    types,
+    enums,
+    thisType,
+    returnTypeInfo: attributeData.returnTypeInfo,
+    dialogueContext: null
+  });
+}
 function compileMigrationAction(status, migrationData) {
   const types = [];
   const attributes = [];
@@ -9257,6 +9910,7 @@ var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
     init_neoscript2();
+    init_document();
     init_convex();
     init_ui();
     init_project_version_intents();
@@ -9638,6 +10292,10 @@ function numberArg(value, name) {
   if (typeof value === "number" && Number.isInteger(value)) return value;
   throw new NSGetterRuntimeError(`${name} must be an integer`);
 }
+function finiteNumberArg(value, name) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  throw new NSGetterRuntimeError(`${name} must be a finite number`);
+}
 function evalPointer(pointer, scope, ctx) {
   switch (pointer.type) {
     case "value" /* value */:
@@ -9900,6 +10558,14 @@ function runtimeTypeCheck(value, checkType, ctx) {
       return isRuntimeSpriteValue(value);
     case 12 /* Audio */:
       return isRuntimeFileValue(value) && !isRuntimeSpriteValue(value);
+    case 14 /* Vector2 */:
+      return isVector2Value(value);
+    case 15 /* Vector2Int */:
+      return isVector2IntValue(value);
+    case 16 /* Vector3 */:
+      return isVector3Value(value);
+    case 17 /* Vector3Int */:
+      return isVector3IntValue(value);
     case 6 /* List */:
     case 9 /* Lookup */:
       return Array.isArray(value);
@@ -9921,6 +10587,24 @@ function runtimeTypeCheck(value, checkType, ctx) {
       return false;
   }
 }
+function evalVectorConstructor(vectorType, componentPointers, scope, ctx) {
+  const values = componentPointers.map(
+    (pointer) => finiteNumberArg(
+      evalPointer(pointer, scope, ctx),
+      `${AttributeType[vectorType]} component`
+    )
+  );
+  const integer = vectorType === 15 /* Vector2Int */ || vectorType === 17 /* Vector3Int */;
+  if (integer && values.some((value) => !Number.isInteger(value))) {
+    throw new NSGetterRuntimeError(
+      `${AttributeType[vectorType]} components must be integers`
+    );
+  }
+  if (vectorType === 14 /* Vector2 */ || vectorType === 15 /* Vector2Int */) {
+    return { x: values[0], y: values[1] };
+  }
+  return { x: values[0], y: values[1], z: values[2] };
+}
 function isRuntimeFileValue(value) {
   if (typeof value !== "object") return false;
   if (value === null) return false;
@@ -10304,6 +10988,14 @@ function evalFunction(fn, scope, ctx) {
       const pointer = evalPointer(fn.info.pointer, scope, ctx);
       return dialogueMemoryVisitCount(pointer, ctx) > 0;
     }
+    case "vectorConstructor" /* vectorConstructor */: {
+      return evalVectorConstructor(
+        fn.info.vectorType,
+        fn.info.componentPointers,
+        scope,
+        ctx
+      );
+    }
     case "count" /* count */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
       return collectionLength(c);
@@ -10645,13 +11337,34 @@ function parseReturns(returns, document) {
   if (returns === null) {
     return RETURN_SHORTHANDS.unknown;
   }
-  const shorthand = RETURN_SHORTHANDS[returns];
-  if (shorthand !== void 0) return shorthand;
-  if (returns.trim().startsWith("{")) {
-    return JSON.parse(returns);
+  const trimmed = returns.trim();
+  if (trimmed.startsWith("{")) {
+    return JSON.parse(trimmed);
+  }
+  return parseReturnExpression(trimmed, document);
+}
+function parseReturnExpression(expression, document) {
+  if (expression.endsWith("[]")) {
+    return {
+      // AttributeType.List
+      type: 6,
+      required: true,
+      entryTypeInfo: parseReturnExpression(
+        expression.slice(0, -2).trim(),
+        document
+      )
+    };
+  }
+  if (expression.endsWith("?")) {
+    return {
+      ...parseReturnExpression(expression.slice(0, -1).trim(), document),
+      required: false
+    };
   }
+  const shorthand = RETURN_SHORTHANDS[expression];
+  if (shorthand !== void 0) return shorthand;
   const type = document.types.find(
-    (entry) => entry.name === returns || entry.id === returns
+    (entry) => entry.name === expression || entry.id === expression
   );
   if (type !== void 0) {
     return {
@@ -10661,7 +11374,7 @@ function parseReturns(returns, document) {
     };
   }
   const enumRecord = document.enums.find(
-    (entry) => entry.name === returns || entry.id === returns
+    (entry) => entry.name === expression || entry.id === expression
   );
   if (enumRecord !== void 0) {
     return {
@@ -10671,7 +11384,7 @@ function parseReturns(returns, document) {
     };
   }
   throw new Error(
-    `--returns "${returns}" is not a shorthand (bool|int|string|float|unknown), a known type/enum name, or TNSTypeInfo JSON.`
+    `--returns "${expression}" is not a shorthand (bool|int|string|float|unknown, with [] / ? suffixes), a known type/enum name, or TNSTypeInfo JSON.`
   );
 }
 function resolveThisType(thisRef, document) {
@@ -10773,8 +11486,9 @@ async function runScript(workspace, command, options) {
         line: error.line,
         column: error.column
       };
+      const hint = options.returns === null && error.message.includes("not assignable to declared return type") ? '\n(eval defaults to an unknown return type \u2014 pass --returns, e.g. --returns "string[]")' : "";
       console.log(
-        options.json ? JSON.stringify(report2, null, 2) : `Compile error at ${error.line}:${error.column} \u2014 ${error.message}`
+        options.json ? JSON.stringify(report2, null, 2) : `Compile error at ${error.line}:${error.column} \u2014 ${error.message}${hint}`
       );
       process.exitCode = 1;
       return;
@@ -10787,6 +11501,10 @@ async function runScript(workspace, command, options) {
     );
     return;
   }
+  if (command === "compile") {
+    console.log(JSON.stringify(compiled, null, 2));
+    return;
+  }
   let evalValues = document.values;
   if (options.save !== null) {
     if (command === "apply") {
@@ -10814,7 +11532,7 @@ async function runScript(workspace, command, options) {
     )
   };
   const overlaidDocument = { ...document, values: evalValues };
-  const evaluatorContext = {
+  const evaluatorContext2 = {
     vm,
     thisValue: resolveThisValue(options.thisRef, overlaidDocument),
     rootValue: buildRootValue(overlaidDocument),
@@ -10823,14 +11541,14 @@ async function runScript(workspace, command, options) {
   if (command === "eval") {
     const value = evaluateNSGetter(
       compiled,
-      evaluatorContext
+      evaluatorContext2
     );
     console.log(
       options.json ? JSON.stringify({ ok: true, value }, null, 2) : JSON.stringify(value, null, 2)
     );
     return;
   }
-  const result = evaluateNSAction(compiled, evaluatorContext);
+  const result = evaluateNSAction(compiled, evaluatorContext2);
   const report = { ok: true, writes: result.writes };
   console.log(
     options.json ? JSON.stringify(report, null, 2) : `${result.writes.length} write intent(s):
@@ -11811,15 +12529,18 @@ async function runBranch(workspace, subcommand, positional, fromRef) {
       console.log(JSON.stringify(versions, null, 2));
       return;
     }
+    const showArchived = process.argv.includes("--all");
     for (const version of versions) {
-      if (version.archivedAt !== null && version.archivedAt !== void 0) {
-        continue;
-      }
+      const archived = version.archivedAt !== null && version.archivedAt !== void 0;
+      if (archived && !showArchived) continue;
       const current = version.id === workspace.config.versionId;
       const marker = current ? color.green("*") : " ";
       const kind = version.kind === "branch" ? `${sym.branch} branch ` : `${sym.tag} version`;
       const label = current ? color.bold(displayLabel(version)) : displayLabel(version);
-      console.log(`${marker} ${kind} ${label}  ${color.dim(version.id)}`);
+      const suffix = archived ? `  ${color.dim("(archived)")}` : "";
+      console.log(
+        `${marker} ${kind} ${label}  ${color.dim(version.id)}${suffix}`
+      );
     }
     return;
   }
@@ -12116,6 +12837,11 @@ async function runMerge(workspace, sourceRef, dryRun, runMigrations = false) {
     success(
       `Merged ${color.bold(String(merged))} record(s) from ${displayLabel(source)}.`
     );
+    if (result.sourceArchived === true) {
+      console.log(
+        `Archived ${displayLabel(source)} \u2014 restore it with "neo branch restore ${typeof source.name === "string" ? source.name : source.id}".`
+      );
+    }
     if (merged > 0) {
       console.log("Pulling merged state...");
       await runPull(workspace, { force: false });
@@ -12274,141 +13000,1035 @@ var init_branch = __esm({
   }
 });
 
-// src/commands/content.ts
-var content_exports = {};
-__export(content_exports, {
-  makeContentContext: () => makeContentContext,
-  runDialogue: () => runDialogue,
-  runFiles: () => runFiles,
-  runLoc: () => runLoc,
-  runRecords: () => runRecords,
-  runValues: () => runValues
+// src/commands/dialogue-spec.ts
+var dialogue_spec_exports = {};
+__export(dialogue_spec_exports, {
+  runDialogueApply: () => runDialogueApply,
+  runDialogueExport: () => runDialogueExport
 });
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { readFileSync as readFileSync9 } from "node:fs";
-function versionPath(workspace, suffix) {
-  return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
-}
-function readBatch(file) {
-  let raw = null;
-  if (file !== null) {
-    raw = readFileSync9(file, "utf8");
-  } else if (!process.stdin.isTTY) {
-    raw = readFileSync9(0, "utf8");
-    if (raw.trim().length === 0) raw = null;
-  }
-  if (raw === null) return null;
-  const parsed = JSON.parse(raw);
-  if (!Array.isArray(parsed)) {
-    throw new Error("Batch input must be a JSON array.");
+async function runDialogueExport(workspace, ref) {
+  const { raw } = await fetchProjectDocument(workspace);
+  const dialogues = Array.isArray(raw.dialogues) ? raw.dialogues.filter(isObjectRecord2) : [];
+  const dialogue = dialogues.find(
+    (entry) => entry.id === ref || entry.name === ref
+  );
+  if (dialogue === void 0) {
+    throw new Error(`No dialogue matches "${ref}".`);
+  }
+  const locById = /* @__PURE__ */ new Map();
+  const texts = Array.isArray(raw.localizedTexts) ? raw.localizedTexts.filter(isObjectRecord2) : [];
+  for (const text of texts) {
+    const locales = isObjectRecord2(text.localeValues) ? text.localeValues : {};
+    const main2 = isObjectRecord2(locales["en-US"]) ? locales["en-US"] : {};
+    if (typeof main2.value === "string") {
+      locById.set(String(text.id), main2.value);
+    }
+  }
+  const nodes = isObjectRecord2(dialogue.nodes) ? dialogue.nodes : {};
+  const keyById = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const [nodeId, node] of Object.entries(nodes)) {
+    let key = typeof node.name === "string" && node.name.length > 0 ? node.name : nodeId.slice(0, 8);
+    while (used.has(key)) key = `${key}_`;
+    used.add(key);
+    keyById.set(nodeId, key);
+  }
+  const refKey = (nodeId) => typeof nodeId === "string" ? keyById.get(nodeId) ?? null : null;
+  const specNodes = {};
+  for (const [nodeId, node] of Object.entries(nodes)) {
+    const spec = {};
+    if (typeof node.text === "string") {
+      spec.say = locById.get(node.text) ?? "";
+    }
+    const optionSettings = isObjectRecord2(node.optionSettings) ? node.optionSettings : null;
+    const options = Array.isArray(optionSettings?.options) ? optionSettings.options.filter(isObjectRecord2) : [];
+    if (options.length > 0) {
+      spec.options = options.map((option) => ({
+        label: option.name ?? "",
+        text: typeof option.text === "string" ? locById.get(option.text) ?? "" : "",
+        to: refKey(option.toNodeId)
+      }));
+    }
+    const actions = Array.isArray(node.actions) ? node.actions.filter(isObjectRecord2) : [];
+    if (actions.length > 0 || node.type === 2) {
+      spec.do = actions.map((action) => {
+        const logic = isObjectRecord2(action.logic) ? action.logic : {};
+        const bind = typeof node.primaryLinkedValueId === "string" ? node.primaryLinkedValueId : void 0;
+        if (typeof logic.code === "string") {
+          return { code: logic.code, bind };
+        }
+        return { ir: logic.action ?? null, bind };
+      });
+    }
+    if (Array.isArray(node.outcomes)) spec.outcomes = node.outcomes;
+    if (typeof node.toNodeId === "string") spec.to = refKey(node.toNodeId);
+    specNodes[keyById.get(nodeId) ?? nodeId] = spec;
   }
-  return parsed;
+  const trigger = isObjectRecord2(dialogue.triggerNode) ? dialogue.triggerNode : null;
+  const groupSettings = trigger !== null && isObjectRecord2(trigger.dialogueGroupSettings) ? trigger.dialogueGroupSettings : null;
+  const priority = groupSettings !== null && isObjectRecord2(groupSettings.priority) ? groupSettings.priority : null;
+  const occurrence = trigger !== null && isObjectRecord2(trigger.occurrenceLimitSettings) ? trigger.occurrenceLimitSettings : null;
+  console.log(
+    JSON.stringify(
+      {
+        id: dialogue.id,
+        name: dialogue.name,
+        description: dialogue.description ?? null,
+        linkedValueId: dialogue.primaryLinkedValueId ?? null,
+        group: groupSettings === null ? null : {
+          id: groupSettings.dialogueGroupId,
+          priority: priority?.priorityTypeId ?? null,
+          relativeOrder: priority?.relativeOrder ?? 0,
+          occurrenceLimit: occurrence?.count ?? null
+        },
+        when: (() => {
+          const conditions = Array.isArray(trigger?.conditions) ? trigger.conditions.filter(isObjectRecord2) : [];
+          const first = conditions[0];
+          return first !== void 0 && typeof first.code === "string" ? first.code : null;
+        })(),
+        start: refKey(trigger?.toNodeId),
+        nodes: specNodes
+      },
+      null,
+      2
+    )
+  );
 }
-async function runRecords(context, subcommand, positional, filterKind) {
-  const { raw, records, heads } = await fetchProjectDocument(context.workspace);
-  if (subcommand === "get") {
-    const [recordKind, recordId] = positional;
-    if (recordKind === void 0 || recordId === void 0) {
-      throw new Error("Usage: neo records get <recordKind> <recordId>");
+async function runDialogueApply(workspace, file, dryRun) {
+  const spec = JSON.parse(readFileSync9(file, "utf8"));
+  if (!isObjectRecord2(spec)) throw new Error("Spec must be a JSON object.");
+  if (typeof spec.name !== "string") throw new Error('Spec needs a "name".');
+  if (!isObjectRecord2(spec.nodes)) throw new Error('Spec needs "nodes".');
+  if (typeof spec.start !== "string") throw new Error('Spec needs "start".');
+  const linkedValueId = typeof spec.linkedValueId === "string" ? spec.linkedValueId : null;
+  if (linkedValueId === null) {
+    throw new Error('Spec needs "linkedValueId" (the bound value id).');
+  }
+  const client = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
+  const base = `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}`;
+  const ids = {};
+  for (const key of Object.keys(spec.nodes)) ids[key] = randomUUID4();
+  if (ids[spec.start] === void 0) {
+    throw new Error(`"start" references unknown node "${spec.start}".`);
+  }
+  const pendingTexts = [];
+  const nodes = {};
+  let index = 0;
+  for (const [key, rawNode] of Object.entries(spec.nodes)) {
+    if (!isObjectRecord2(rawNode)) {
+      throw new Error(`Node "${key}" must be an object.`);
+    }
+    const nodeId = ids[key];
+    const layout = {
+      x: index % 4 * 380,
+      y: 220 + Math.floor(index / 4) * 240,
+      width: 320,
+      height: 160,
+      isOpen: true
+    };
+    index += 1;
+    const resolveTo = (target) => {
+      if (target === null || target === void 0) return void 0;
+      const id = ids[String(target)];
+      if (id === void 0) {
+        throw new Error(
+          `Node "${key}" points at unknown node "${String(target)}".`
+        );
+      }
+      return id;
+    };
+    if (Array.isArray(rawNode.do)) {
+      const groups = [];
+      for (const step of rawNode.do) {
+        if (!isObjectRecord2(step)) {
+          throw new Error(`Node "${key}" has a non-object "do" step.`);
+        }
+        const bind = typeof step.bind === "string" ? step.bind : linkedValueId;
+        const last = groups[groups.length - 1];
+        if (last !== void 0 && last.bind === bind) {
+          last.steps.push(step);
+        } else {
+          groups.push({ bind, steps: [step] });
+        }
+      }
+      let chainNodeId = nodeId;
+      for (const [index2, group2] of groups.entries()) {
+        const actions = [];
+        for (const step of group2.steps) {
+          let ir = step.ir;
+          if (typeof step.code === "string") {
+            const compiled = await client.post(
+              `${base}/dialogue-logic/compile`,
+              {
+                code: step.code,
+                target: 1,
+                dialogue: {},
+                node: { primaryLinkedValueId: group2.bind }
+              }
+            );
+            ir = compiled.action;
+          }
+          if (!isObjectRecord2(ir)) {
+            throw new Error(`Node "${key}" "do" step needs "code" or "ir".`);
+          }
+          actions.push({
+            id: randomUUID4(),
+            type: 0,
+            logic: typeof step.code === "string" ? { type: 1, code: step.code, action: ir } : { type: 0, action: ir }
+          });
+        }
+        const isLast = index2 === groups.length - 1;
+        const nextChainId = isLast ? void 0 : randomUUID4();
+        nodes[chainNodeId] = {
+          id: chainNodeId,
+          type: 2,
+          name: index2 === 0 ? key : `${key} (${index2 + 1})`,
+          layout,
+          linkedValues: [.../* @__PURE__ */ new Set([linkedValueId, group2.bind])].map(
+            (valueId) => ({ source: 1, valueId })
+          ),
+          primaryLinkedValueId: group2.bind,
+          actions,
+          ...isLast ? resolveTo(rawNode.to) !== void 0 ? { toNodeId: resolveTo(rawNode.to) } : {} : { toNodeId: nextChainId }
+        };
+        if (nextChainId !== void 0) chainNodeId = nextChainId;
+      }
+      continue;
     }
-    const fromMap = records.get(`${recordKind}:${recordId}`);
-    if (fromMap !== void 0) {
-      console.log(JSON.stringify(fromMap, null, 2));
-      return;
+    if (typeof rawNode.say !== "string") {
+      throw new Error(`Node "${key}" needs "say" (text) or "do" (actions).`);
     }
-    for (const value of Object.values(raw)) {
-      if (!Array.isArray(value)) continue;
-      for (const entry of value) {
-        if (isObjectRecord2(entry) && entry.id === recordId) {
-          console.log(JSON.stringify(entry, null, 2));
-          return;
+    const textId = randomUUID4();
+    pendingTexts.push({
+      textId,
+      value: rawNode.say,
+      nodeId,
+      choiceId: null
+    });
+    const node = {
+      id: nodeId,
+      type: 1,
+      name: key,
+      layout,
+      linkedValues: [{ source: 1, valueId: linkedValueId }],
+      primaryLinkedValueId: linkedValueId,
+      text: textId,
+      variables: null
+    };
+    if (Array.isArray(rawNode.options) && rawNode.options.length > 0) {
+      const options = [];
+      for (const rawOption of rawNode.options) {
+        if (!isObjectRecord2(rawOption)) {
+          throw new Error(`Node "${key}" has a non-object option.`);
+        }
+        const option = rawOption;
+        const optionId = randomUUID4();
+        const optionTextId = randomUUID4();
+        let optionSettings = null;
+        if (typeof option.if === "string") {
+          const compiledIf = await client.post(
+            `${base}/dialogue-logic/compile`,
+            {
+              code: option.if,
+              target: 0,
+              dialogue: { primaryLinkedValueId: linkedValueId },
+              node: { primaryLinkedValueId: linkedValueId }
+            }
+          );
+          optionSettings = {
+            selectableConditions: [
+              { type: 1, code: option.if, getter: compiledIf.getter }
+            ]
+          };
         }
+        options.push({
+          id: optionId,
+          name: option.label,
+          text: optionTextId,
+          toNodeId: resolveTo(option.to),
+          variables: null,
+          ...optionSettings === null ? {} : { settings: optionSettings }
+        });
+        pendingTexts.push({
+          textId: optionTextId,
+          value: option.text,
+          nodeId,
+          choiceId: optionId
+        });
       }
+      node.optionSettings = { options };
+    } else if (resolveTo(rawNode.to) !== void 0) {
+      node.toNodeId = resolveTo(rawNode.to);
     }
-    throw new Error(`Record "${recordKind}:${recordId}" was not found.`);
+    nodes[nodeId] = node;
   }
-  if (subcommand === "query") {
-    const result = [];
-    for (const head of heads.values()) {
-      if (filterKind !== null && head.recordKind !== filterKind) continue;
-      result.push({ ...head });
-    }
-    console.log(JSON.stringify(result, null, 2));
-    return;
+  const group = isObjectRecord2(spec.group) ? spec.group : null;
+  const triggerConditions = [];
+  if (typeof spec.when === "string") {
+    const compiled = await client.post(
+      `${base}/dialogue-logic/compile`,
+      {
+        code: spec.when,
+        target: 0,
+        dialogue: {
+          primaryLinkedValueId: linkedValueId,
+          triggerNode: {
+            primaryLinkedValueId: linkedValueId,
+            dialogueGroupSettings: group === null ? null : { lookupValueId: linkedValueId }
+          }
+        }
+      }
+    );
+    triggerConditions.push({
+      type: 1,
+      code: spec.when,
+      getter: compiled.getter
+    });
   }
-  throw new Error(`Unknown records subcommand "${subcommand}".`);
-}
-async function runValues(context, subcommand, positional, file) {
-  if (subcommand === "get" || subcommand === "list") {
-    const { raw } = await fetchProjectDocument(context.workspace);
-    const values = Array.isArray(raw.values) ? raw.values.filter(isObjectRecord2) : [];
-    if (subcommand === "get") {
-      const valueId = positional[0];
-      if (valueId === void 0)
-        throw new Error("Usage: neo values get <valueId>");
-      const value = values.find((entry) => entry.id === valueId);
-      if (value === void 0)
-        throw new Error(`Value "${valueId}" was not found.`);
-      console.log(JSON.stringify(value, null, 2));
-      return;
-    }
-    const attributeId = positional[0] ?? null;
-    const filtered = attributeId === null ? values : values.filter((entry) => entry.attributeId === attributeId);
+  const trigger = {
+    id: randomUUID4(),
+    type: 0,
+    name: null,
+    layout: { x: 0, y: 0, width: 320, height: 160, isOpen: true },
+    linkedValues: [{ source: 3, valueId: linkedValueId }],
+    primaryLinkedValueId: linkedValueId,
+    conditions: triggerConditions,
+    dialogueGroupSettings: group === null ? null : {
+      dialogueGroupId: group.id,
+      lookupValueId: linkedValueId,
+      priority: {
+        priorityTypeId: group.priority,
+        relativeOrder: typeof group.relativeOrder === "number" ? group.relativeOrder : 0
+      }
+    },
+    occurrenceLimitSettings: group !== null && typeof group.occurrenceLimit === "number" ? { count: group.occurrenceLimit } : null,
+    toNodeId: ids[spec.start]
+  };
+  const body = {
+    name: spec.name,
+    description: typeof spec.description === "string" ? spec.description : null,
+    nodes,
+    linkedValues: [{ source: 3, valueId: linkedValueId }],
+    primaryLinkedValueId: linkedValueId,
+    settings: { defaultSaveOptionChoices: true },
+    triggerNode: trigger
+  };
+  if (dryRun) {
     console.log(
-      JSON.stringify(
-        filtered.map((entry) => ({
-          id: entry.id,
-          attributeId: entry.attributeId,
-          value: entry.value
-        })),
-        null,
-        2
-      )
+      `Would create "${spec.name}": ${Object.keys(nodes).length} node(s), ${pendingTexts.length} string(s).`
     );
     return;
   }
-  if (subcommand === "set") {
-    const batch = readBatch(file);
-    const edits = [];
-    if (batch !== null) {
-      for (const entry of batch) {
-        if (!isObjectRecord2(entry) || typeof entry.valueId !== "string") {
-          throw new Error(
-            'values set batch entries need {"valueId", "value"}.'
-          );
-        }
-        edits.push({ valueId: entry.valueId, value: entry.value });
-      }
-    } else {
-      const [valueId, valueJson] = positional;
-      if (valueId === void 0 || valueJson === void 0) {
-        throw new Error(
-          "Usage: neo values set <valueId> <valueJson> (or batch via stdin/--file)"
-        );
-      }
-      edits.push({ valueId, value: JSON.parse(valueJson) });
-    }
-    const { heads, raw } = await fetchProjectDocument(context.workspace);
-    const valueById = new Map(
-      (Array.isArray(raw.values) ? raw.values.filter(isObjectRecord2) : []).map(
-        (value) => [String(value.id), value]
-      )
-    );
-    const now = Date.now();
-    const convex = await createConvexClient(context.workspace);
-    await convex.mutation(api.serverProjectRecordOperations.commitFromSession, {
-      projectId: context.workspace.config.projectId,
-      versionId: context.workspace.config.versionId,
-      operation: "update",
-      changes: edits.map((edit) => {
-        const record = valueById.get(edit.valueId);
-        if (record === void 0) {
-          throw new Error(`Value "${edit.valueId}" was not found.`);
-        }
-        return {
-          recordKind: "value",
-          recordId: edit.valueId,
+  const created = await client.post(
+    `${base}/dialogues/create`,
+    body
+  );
+  const dialogue = isObjectRecord2(created.dialogue) ? created.dialogue : created;
+  const dialogueId = String(dialogue.id);
+  const convex = await createConvexClient(workspace);
+  const now = Date.now();
+  await convex.mutation(api.serverProjectRecordOperations.commitFromSession, {
+    projectId: workspace.config.projectId,
+    versionId: workspace.config.versionId,
+    operation: "create",
+    changes: pendingTexts.map((text) => ({
+      recordKind: "localized-text",
+      recordId: text.textId,
+      operation: "create",
+      nextData: {
+        id: text.textId,
+        projectId: workspace.config.projectId,
+        sourceComment: null,
+        links: [
+          text.choiceId === null ? {
+            kind: "dialogue-node-text",
+            recordKind: "dialogue-node",
+            recordId: text.nodeId,
+            nodeId: text.nodeId,
+            fieldPath: "text"
+          } : {
+            kind: "dialogue-choice-text",
+            recordKind: "dialogue-node",
+            recordId: text.nodeId,
+            nodeId: text.nodeId,
+            choiceId: text.choiceId,
+            fieldPath: `optionSettings.options.${text.choiceId}.text`
+          }
+        ],
+        localeValues: {
+          "en-US": {
+            value: text.value,
+            statusId: "localization-status-approved",
+            localeComment: null,
+            updatedAt: now
+          }
+        },
+        createdAt: now,
+        updatedAt: now
+      },
+      intent: createProjectVersionIntent("localized-text.create", {
+        source: "neo-cli-dialogue-apply"
+      }),
+      expectedBaseContentHash: null
+    })),
+    summary: `neo dialogue apply: ${spec.name}`
+  });
+  success(
+    `Created "${spec.name}" (${dialogueId}) \u2014 ${Object.keys(nodes).length} node(s), ${pendingTexts.length} string(s).`
+  );
+  console.log(`${sym.arrow} validate it: neo dialogue dryrun ${dialogueId}`);
+}
+var init_dialogue_spec = __esm({
+  "src/commands/dialogue-spec.ts"() {
+    "use strict";
+    init_document();
+    init_projection();
+    init_convex();
+    init_project_version_intents();
+    init_http();
+    init_ui();
+  }
+});
+
+// src/commands/dialogue-dryrun.ts
+var dialogue_dryrun_exports = {};
+__export(dialogue_dryrun_exports, {
+  runDialogueDryrun: () => runDialogueDryrun
+});
+async function runDialogueDryrun(workspace, ref, json) {
+  const { raw } = await fetchProjectDocument(workspace);
+  const document = readDocumentArrays(raw);
+  const world = buildWorld(document, raw);
+  const dialogues = (Array.isArray(raw.dialogues) ? raw.dialogues.filter(isObjectRecord2) : []).filter(
+    (dialogue) => ref === null || dialogue.id === ref || dialogue.name === ref
+  );
+  if (dialogues.length === 0) {
+    throw new Error(
+      ref === null ? "The project has no dialogues." : `No dialogue matches "${ref}".`
+    );
+  }
+  const reports = dialogues.map((dialogue) => dryrunDialogue(dialogue, world));
+  if (json) {
+    console.log(JSON.stringify(reports, null, 2));
+  } else {
+    for (const report of reports) printReport(report);
+    const failed = reports.filter((report) => report.violations.length > 0);
+    console.log("");
+    if (failed.length === 0) {
+      console.log(
+        `${sym.ok} ${reports.length} dialogue(s) dry-ran clean from a fresh save.`
+      );
+    } else {
+      console.log(
+        `${sym.fail} ${failed.length}/${reports.length} dialogue(s) have violations.`
+      );
+    }
+  }
+  if (reports.some((report) => report.violations.length > 0)) {
+    process.exitCode = 1;
+  }
+}
+function buildWorld(document, raw) {
+  const valueById = new Map(
+    document.values.map((value) => [String(value.id), value])
+  );
+  const attributeById = new Map(
+    document.attributes.map((attribute) => [String(attribute.id), attribute])
+  );
+  const reachable = (rootContainerId) => {
+    const seen = /* @__PURE__ */ new Set();
+    const queue = rootContainerId === null ? [] : [rootContainerId];
+    while (queue.length > 0) {
+      const id = queue.pop();
+      if (id === void 0 || seen.has(id)) continue;
+      const record = valueById.get(id);
+      if (record === void 0) continue;
+      seen.add(id);
+      const value = record.value;
+      const children = Array.isArray(value) ? value : isObjectRecord2(value) ? Object.values(value) : [];
+      for (const child of children) {
+        if (typeof child === "string" && valueById.has(child)) {
+          queue.push(child);
+        }
+      }
+    }
+    return seen;
+  };
+  let saveOwned = /* @__PURE__ */ new Set();
+  let sessionOwned = /* @__PURE__ */ new Set();
+  for (const { root, attributeId } of projectRootAttributesInDisplayOrder(
+    document.project
+  )) {
+    const attribute = attributeById.get(attributeId);
+    const containerId = attribute !== void 0 && typeof attribute.valueId === "string" ? attribute.valueId : null;
+    if (root.key === "Save") saveOwned = reachable(containerId);
+    if (root.key === "Session") sessionOwned = reachable(containerId);
+  }
+  const locById = /* @__PURE__ */ new Map();
+  const texts = Array.isArray(raw.localizedTexts) ? raw.localizedTexts.filter(isObjectRecord2) : [];
+  for (const text of texts) {
+    const locales = isObjectRecord2(text.localeValues) ? text.localeValues : {};
+    const main2 = isObjectRecord2(locales["en-US"]) ? locales["en-US"] : {};
+    locById.set(
+      String(text.id),
+      typeof main2.value === "string" ? main2.value : null
+    );
+  }
+  const lookupKeys = /* @__PURE__ */ new Set();
+  const lookupAttributeIds = new Set(
+    document.attributes.filter((attribute) => attribute.type === 9).map((attribute) => String(attribute.id))
+  );
+  for (const type of document.types) {
+    if (!isObjectRecord2(type.schema)) continue;
+    for (const [key, attributeId] of Object.entries(type.schema)) {
+      if (typeof attributeId === "string" && lookupAttributeIds.has(attributeId)) {
+        lookupKeys.add(key);
+      }
+    }
+  }
+  return {
+    valueById,
+    rootValue: buildRootValue(document),
+    vm: {
+      project: document.project,
+      attributes: document.attributes,
+      values: document.values,
+      types: document.types,
+      enums: document.enums,
+      projectFiles: document.projectFiles,
+      localizationConfig: document.localizationConfig,
+      localizedTexts: document.localizedTexts,
+      databaseVM: makeEvaluatorLookups(
+        document.attributes,
+        document.values
+      )
+    },
+    saveOwned,
+    sessionOwned,
+    locById,
+    lookupKeys
+  };
+}
+function dryrunDialogue(dialogue, world) {
+  const name = String(dialogue.name ?? dialogue.id);
+  const nodes = isObjectRecord2(dialogue.nodes) ? dialogue.nodes : {};
+  const report = {
+    dialogue: name,
+    dialogueId: String(dialogue.id),
+    nodesVisited: 0,
+    nodesTotal: Object.keys(nodes).length,
+    pathsWalked: 0,
+    endings: 0,
+    actionsEvaluated: 0,
+    violations: [],
+    warnings: []
+  };
+  const violate = (node, message) => {
+    report.violations.push({ dialogue: name, node, message });
+  };
+  const trigger = isObjectRecord2(dialogue.triggerNode) ? dialogue.triggerNode : null;
+  const start = trigger?.toNodeId;
+  if (typeof start !== "string") {
+    report.warnings.push("no trigger entry point \u2014 dialogue can never fire");
+    return report;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const evaluatedActionNodes = /* @__PURE__ */ new Set();
+  const walk = (nodeId, pathSeen) => {
+    const node = nodes[nodeId];
+    if (node === void 0) {
+      violate(nodeId.slice(0, 8), "edge points at a node that does not exist");
+      return;
+    }
+    if (pathSeen.has(nodeId)) return;
+    const nextSeen = new Set(pathSeen);
+    nextSeen.add(nodeId);
+    visited.add(nodeId);
+    const label = String(node.name ?? nodeId.slice(0, 8));
+    if (typeof node.text === "string") {
+      const value = world.locById.get(node.text);
+      if (value === void 0) violate(label, "node text record is missing");
+      else if (value === null || value === "")
+        violate(label, "node text has no en-US value");
+    }
+    if (node.type === 2 && !evaluatedActionNodes.has(nodeId)) {
+      evaluatedActionNodes.add(nodeId);
+      runActions(node, label, world, report, violate);
+    }
+    const edges = [];
+    if (typeof node.toNodeId === "string") edges.push(node.toNodeId);
+    const optionSettings = isObjectRecord2(node.optionSettings) ? node.optionSettings : null;
+    const options = Array.isArray(optionSettings?.options) ? optionSettings.options.filter(isObjectRecord2) : [];
+    for (const option of options) {
+      const text = typeof option.text === "string" ? world.locById.get(option.text) : void 0;
+      if (text === void 0)
+        violate(label, `option "${String(option.name)}" text record missing`);
+      else if (text === null || text === "")
+        violate(label, `option "${String(option.name)}" has no en-US value`);
+      if (typeof option.toNodeId === "string") edges.push(option.toNodeId);
+      else violate(label, `option "${String(option.name)}" leads nowhere`);
+    }
+    const outcomes = Array.isArray(node.outcomes) ? node.outcomes.filter(isObjectRecord2) : [];
+    for (const outcome of outcomes) {
+      runOutcomeConditions(node, outcome, label, world, report, violate);
+      if (typeof outcome.toNodeId === "string") edges.push(outcome.toNodeId);
+    }
+    if (edges.length === 0) {
+      report.pathsWalked += 1;
+      report.endings += 1;
+      return;
+    }
+    for (const edge of edges) walk(edge, nextSeen);
+  };
+  walk(start, /* @__PURE__ */ new Set());
+  report.nodesVisited = visited.size;
+  for (const [nodeId, node] of Object.entries(nodes)) {
+    if (!visited.has(nodeId)) {
+      report.warnings.push(
+        `unreachable node "${String(node.name ?? nodeId.slice(0, 8))}"`
+      );
+    }
+  }
+  return report;
+}
+function evaluatorContext(node, world) {
+  const primary = typeof node.primaryLinkedValueId === "string" ? node.primaryLinkedValueId : null;
+  const thisRecord = primary === null ? null : world.valueById.get(primary);
+  return {
+    vm: world.vm,
+    thisValue: thisRecord?.value ?? null,
+    rootValue: world.rootValue,
+    dialogueContext: null
+  };
+}
+function runActions(node, label, world, report, violate) {
+  const actions = Array.isArray(node.actions) ? node.actions.filter(isObjectRecord2) : [];
+  const ctx = evaluatorContext(node, world);
+  for (const action of actions) {
+    const logic = isObjectRecord2(action.logic) ? action.logic : null;
+    const compiled = logic !== null ? logic.action : void 0;
+    if (!isObjectRecord2(compiled)) {
+      report.warnings.push(
+        `"${label}" has an action with no compiled logic (no-op)`
+      );
+      continue;
+    }
+    report.actionsEvaluated += 1;
+    checkLookupMutationArgs(compiled, label, world, violate);
+    let writes;
+    try {
+      writes = evaluateNSAction(compiled, ctx).writes;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("no native delegate is available")) {
+        report.warnings.push(
+          `"${label}" calls a native function \u2014 skipped in simulation (${message.split("'")[1] ?? "native"})`
+        );
+      } else {
+        violate(label, `action failed to evaluate: ${message}`);
+      }
+      continue;
+    }
+    for (const write of writes) {
+      checkWriteOwnership(write, compiled, label, ctx, world, violate);
+    }
+  }
+}
+function runOutcomeConditions(node, outcome, label, world, report, violate) {
+  const conditions = Array.isArray(outcome.conditions) ? outcome.conditions.filter(isObjectRecord2) : [];
+  const ctx = evaluatorContext(node, world);
+  for (const condition of conditions) {
+    if (!isObjectRecord2(condition.getter)) continue;
+    report.actionsEvaluated += 1;
+    try {
+      const value = evaluateNSGetter(condition.getter, ctx);
+      if (typeof value !== "boolean") {
+        violate(label, `outcome condition returned ${typeof value}, not bool`);
+      }
+    } catch (error) {
+      violate(
+        label,
+        `outcome condition failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+function checkWriteOwnership(write, compiledAction, label, ctx, world, violate) {
+  const target = isObjectRecord2(write.target) ? write.target : null;
+  if (target === null) {
+    violate(label, `${write.kind} write has no target`);
+    return;
+  }
+  if (write.kind !== "assign") {
+    const literalKey = targetLiteralKey(target);
+    if (literalKey !== null && world.lookupKeys.has(literalKey)) return;
+  }
+  const writability = typeof target.writability === "string" ? target.writability : null;
+  const sessionLike = writability === "session" || writability === "assetToSessionLookup" || writability === "local";
+  const saveLike = writability === "save" || writability === "assetToSaveLookup";
+  if (writability !== null && !saveLike && !sessionLike) {
+    violate(
+      label,
+      `${write.kind} write targets a ${writability} value \u2014 the runtime refuses non save/session mutations`
+    );
+    return;
+  }
+  const rowId = resolveWriteRowId(target, compiledAction, ctx, world);
+  if (rowId === null) {
+    violate(
+      label,
+      `${write.kind} write receiver did not resolve to a stored value row \u2014 null lookup (missing save-map entry?) or a lookup-resolved asset collection; the runtime cannot apply this write`
+    );
+    return;
+  }
+  const owned = sessionLike ? world.sessionOwned.has(rowId) : world.saveOwned.has(rowId);
+  if (!owned) {
+    violate(
+      label,
+      `${write.kind} write lands on '${rowId}' which is not ${sessionLike ? "session" : "save"}-owned \u2014 the runtime will throw exactly here`
+    );
+  }
+}
+function checkLookupMutationArgs(compiledAction, label, world, violate) {
+  const scan = (value) => {
+    if (Array.isArray(value)) {
+      for (const entry of value) scan(entry);
+      return;
+    }
+    if (!isObjectRecord2(value)) return;
+    const mutation = value.mutation;
+    const target = isObjectRecord2(value.target) ? value.target : null;
+    if (typeof mutation === "string" && target !== null) {
+      const literalKey = targetLiteralKey(target);
+      if (literalKey !== null && world.lookupKeys.has(literalKey)) {
+        const args = Array.isArray(value.args) ? value.args : [];
+        for (const arg of args) {
+          if (isObjectRecord2(arg) && arg.type === "value" && isObjectRecord2(arg.value) && typeof arg.value.value === "string") {
+            violate(
+              label,
+              `${mutation} on lookup "${literalKey}" passes an id string literal \u2014 the runtime needs a collection entry (bind the node to the item and use Add(this))`
+            );
+          }
+        }
+      }
+    }
+    for (const child of Object.values(value)) scan(child);
+  };
+  scan(compiledAction.instructions);
+}
+function targetLiteralKey(target) {
+  const pointer = isObjectRecord2(target.pointer) ? target.pointer : target;
+  if (pointer.type !== "keyOf" || !isObjectRecord2(pointer.keyOf)) return null;
+  const key = pointer.keyOf.key;
+  if (!isObjectRecord2(key) || !isObjectRecord2(key.value)) return null;
+  return typeof key.value.value === "string" ? key.value.value : null;
+}
+function resolveWriteRowId(target, compiledAction, ctx, world) {
+  const pointer = isObjectRecord2(target.pointer) ? target.pointer : target;
+  const evalPointer2 = (p) => {
+    const getter = {
+      parameters: compiledAction.parameters ?? [],
+      instructions: [{ type: "return", pointer: p }],
+      typeInfo: { type: 0, required: false }
+    };
+    try {
+      return evaluateNSGetter(getter, ctx);
+    } catch {
+      return void 0;
+    }
+  };
+  if (pointer.type === "keyOf" && isObjectRecord2(pointer.keyOf)) {
+    const keyOf = pointer.keyOf;
+    const key = isObjectRecord2(keyOf.key) ? keyOf.key : null;
+    const literalKey = key !== null && isObjectRecord2(key.value) ? key.value.value : void 0;
+    const receiver2 = evalPointer2(keyOf.pointer);
+    if (isObjectRecord2(receiver2) && typeof literalKey === "string") {
+      const child = receiver2[literalKey];
+      if (typeof child === "string" && world.valueById.has(child)) {
+        return child;
+      }
+    }
+    return null;
+  }
+  if (pointer.type === "reference" && typeof pointer.valueId === "string") {
+    return pointer.valueId;
+  }
+  const receiver = evalPointer2(pointer);
+  if (receiver !== void 0 && receiver !== null) {
+    for (const [id, record] of world.valueById) {
+      if (record.value === receiver) return id;
+    }
+  }
+  return null;
+}
+function printReport(report) {
+  const headline = `${report.dialogue}  ${color.dim(
+    `${report.nodesVisited}/${report.nodesTotal} nodes, ${report.endings} ending(s), ${report.actionsEvaluated} action/condition eval(s)`
+  )}`;
+  if (report.violations.length === 0) {
+    console.log(`${sym.ok} ${headline}`);
+  } else {
+    console.log(`${sym.fail} ${headline}`);
+    for (const violation of report.violations) {
+      console.log(`    ${color.red(violation.node)}: ${violation.message}`);
+    }
+  }
+  for (const warning of report.warnings) {
+    console.log(`    ${sym.warn} ${color.dim(warning)}`);
+  }
+}
+var init_dialogue_dryrun = __esm({
+  "src/commands/dialogue-dryrun.ts"() {
+    "use strict";
+    init_document();
+    init_projection();
+    init_neoscript_evaluator();
+    init_project_root_attributes();
+    init_ui();
+    init_script();
+  }
+});
+
+// src/commands/content.ts
+var content_exports = {};
+__export(content_exports, {
+  makeContentContext: () => makeContentContext,
+  runDialogue: () => runDialogue,
+  runFiles: () => runFiles,
+  runLoc: () => runLoc,
+  runRecords: () => runRecords,
+  runValues: () => runValues
+});
+import { readFileSync as readFileSync10 } from "node:fs";
+import { randomUUID as randomUUID5 } from "node:crypto";
+function versionPath(workspace, suffix) {
+  return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
+}
+function readBatch(file) {
+  let raw = null;
+  if (file !== null) {
+    raw = readFileSync10(file, "utf8");
+  } else if (!process.stdin.isTTY) {
+    raw = readFileSync10(0, "utf8");
+    if (raw.trim().length === 0) raw = null;
+  }
+  if (raw === null) return null;
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Batch input must be a JSON array.");
+  }
+  return parsed;
+}
+async function runRecords(context, subcommand, positional, filterKind) {
+  const { raw, records, heads } = await fetchProjectDocument(context.workspace);
+  if (subcommand === "get") {
+    const [recordKind, recordId] = positional;
+    if (recordKind === void 0 || recordId === void 0) {
+      throw new Error("Usage: neo records get <recordKind> <recordId>");
+    }
+    const fromMap = records.get(`${recordKind}:${recordId}`);
+    if (fromMap !== void 0) {
+      console.log(JSON.stringify(fromMap, null, 2));
+      return;
+    }
+    for (const value of Object.values(raw)) {
+      if (!Array.isArray(value)) continue;
+      for (const entry of value) {
+        if (isObjectRecord2(entry) && entry.id === recordId) {
+          console.log(JSON.stringify(entry, null, 2));
+          return;
+        }
+      }
+    }
+    throw new Error(`Record "${recordKind}:${recordId}" was not found.`);
+  }
+  if (subcommand === "query") {
+    const result = [];
+    for (const head of heads.values()) {
+      if (filterKind !== null && head.recordKind !== filterKind) continue;
+      result.push({ ...head });
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  throw new Error(`Unknown records subcommand "${subcommand}".`);
+}
+async function runValues(context, subcommand, positional, file) {
+  if (subcommand === "get" || subcommand === "list") {
+    const { raw } = await fetchProjectDocument(context.workspace);
+    const values = Array.isArray(raw.values) ? raw.values.filter(isObjectRecord2) : [];
+    if (subcommand === "get") {
+      const valueId = positional[0];
+      if (valueId === void 0)
+        throw new Error("Usage: neo values get <valueId>");
+      const value = values.find((entry) => entry.id === valueId);
+      if (value === void 0)
+        throw new Error(`Value "${valueId}" was not found.`);
+      console.log(JSON.stringify(value, null, 2));
+      return;
+    }
+    const attributeId = positional[0] ?? null;
+    const filtered = attributeId === null ? values : values.filter((entry) => entry.attributeId === attributeId);
+    console.log(
+      JSON.stringify(
+        filtered.map((entry) => ({
+          id: entry.id,
+          attributeId: entry.attributeId,
+          value: entry.value
+        })),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "add-entry" || subcommand === "delete-entry") {
+    const containerValueId = positional[0];
+    const jsonArg = positional[1];
+    if (containerValueId === void 0 || jsonArg === void 0) {
+      throw new Error(
+        `Usage: neo values ${subcommand} <containerValueId> '<json>'`
+      );
+    }
+    const verb = subcommand === "add-entry" ? "add" : "delete";
+    const result = await context.client.post(
+      versionPath(
+        context.workspace,
+        `values/${containerValueId}/entries/${verb}`
+      ),
+      JSON.parse(jsonArg)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "create") {
+    const jsonArg = positional[0];
+    if (jsonArg === void 0) {
+      throw new Error(
+        "Usage: neo values create '<valueJson>' [--into <containerValueId> --key <AttributeName>]"
+      );
+    }
+    const intoIndex = process.argv.indexOf("--into");
+    const keyIndex = process.argv.indexOf("--key");
+    const containerValueId = intoIndex >= 0 ? process.argv[intoIndex + 1] ?? null : null;
+    const containerKey = keyIndex >= 0 ? process.argv[keyIndex + 1] ?? null : null;
+    if (containerValueId === null !== (containerKey === null)) {
+      throw new Error(
+        "values create needs BOTH --into and --key (or neither)."
+      );
+    }
+    const newValueId = randomUUID5();
+    const { heads, raw } = await fetchProjectDocument(context.workspace);
+    const changes = [
+      {
+        recordKind: "value",
+        recordId: newValueId,
+        operation: "create",
+        // Full IAttributeValueProps shape — the export read bundle validates
+        // every value record (id/projectId/value/createdAt/updatedAt).
+        nextData: {
+          id: newValueId,
+          projectId: context.workspace.config.projectId,
+          value: JSON.parse(jsonArg),
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        },
+        intent: createProjectVersionIntent("value.create", {
+          source: "neo-cli-values"
+        }),
+        expectedBaseContentHash: null
+      }
+    ];
+    if (containerValueId !== null && containerKey !== null) {
+      const values = Array.isArray(raw.values) ? raw.values.filter(isObjectRecord2) : [];
+      const container = values.find((value) => value.id === containerValueId);
+      if (container === void 0) {
+        throw new Error(`Container value "${containerValueId}" was not found.`);
+      }
+      if (!isObjectRecord2(container.value)) {
+        throw new Error(
+          `Container value "${containerValueId}" is not an attribute map.`
+        );
+      }
+      changes.push({
+        recordKind: "value",
+        recordId: containerValueId,
+        operation: "update",
+        nextData: {
+          ...container,
+          value: { ...container.value, [containerKey]: newValueId }
+        },
+        intent: createProjectVersionIntent("value.update", {
+          source: "neo-cli-values"
+        }),
+        expectedBaseContentHash: heads.get(`value:${containerValueId}`)?.contentHash ?? null
+      });
+    }
+    const convex = await createConvexClient(context.workspace);
+    await convex.mutation(api.serverProjectRecordOperations.commitFromSession, {
+      projectId: context.workspace.config.projectId,
+      versionId: context.workspace.config.versionId,
+      operation: "create",
+      changes,
+      summary: "neo values create",
+      force: true
+    });
+    console.log(newValueId);
+    return;
+  }
+  if (subcommand === "set") {
+    const batch = readBatch(file);
+    const edits = [];
+    if (batch !== null) {
+      for (const entry of batch) {
+        if (!isObjectRecord2(entry) || typeof entry.valueId !== "string") {
+          throw new Error(
+            'values set batch entries need {"valueId", "value"}.'
+          );
+        }
+        edits.push({ valueId: entry.valueId, value: entry.value });
+      }
+    } else {
+      const [valueId, valueJson] = positional;
+      if (valueId === void 0 || valueJson === void 0) {
+        throw new Error(
+          "Usage: neo values set <valueId> <valueJson> (or batch via stdin/--file)"
+        );
+      }
+      edits.push({ valueId, value: JSON.parse(valueJson) });
+    }
+    const { heads, raw } = await fetchProjectDocument(context.workspace);
+    const valueById = new Map(
+      (Array.isArray(raw.values) ? raw.values.filter(isObjectRecord2) : []).map(
+        (value) => [String(value.id), value]
+      )
+    );
+    const now = Date.now();
+    const convex = await createConvexClient(context.workspace);
+    await convex.mutation(api.serverProjectRecordOperations.commitFromSession, {
+      projectId: context.workspace.config.projectId,
+      versionId: context.workspace.config.versionId,
+      operation: "update",
+      changes: edits.map((edit) => {
+        const record = valueById.get(edit.valueId);
+        if (record === void 0) {
+          throw new Error(`Value "${edit.valueId}" was not found.`);
+        }
+        return {
+          recordKind: "value",
+          recordId: edit.valueId,
           operation: "update",
-          nextData: { ...record, value: edit.value, updatedAt: now },
+          // Backfill the required record envelope (repairs rows minted by
+          // older CLI builds that wrote only {id, value}).
+          nextData: {
+            projectId: context.workspace.config.projectId,
+            createdAt: now,
+            ...record,
+            value: edit.value,
+            updatedAt: now
+          },
           intent: createProjectVersionIntent("value.update", {
             source: "neo-cli-values"
           }),
@@ -12471,6 +14091,107 @@ async function runLoc(context, subcommand, positional, file) {
     }
     return;
   }
+  if (subcommand === "create") {
+    const jsonArg = positional[0];
+    if (jsonArg === void 0 || !jsonArg.trim().startsWith("{")) {
+      throw new Error(
+        `Usage: neo loc create '{"value":"...","locale":"en-US","links":[...]}'`
+      );
+    }
+    const body = JSON.parse(jsonArg);
+    if (typeof body.value !== "string") {
+      throw new Error('loc create requires a string "value".');
+    }
+    const locale = typeof body.locale === "string" ? body.locale : "en-US";
+    const { heads, raw } = await fetchProjectDocument(context.workspace);
+    const config = isObjectRecord2(raw.localizationConfig) ? raw.localizationConfig : {};
+    const statusId = config.mainLocale === locale && typeof config.mainLocaleDefaultStatusId === "string" ? config.mainLocaleDefaultStatusId : "localization-status-needs-translation";
+    const now = Date.now();
+    const textId = typeof body.id === "string" ? body.id : randomUUID5();
+    const existingHead = heads.get(`localized-text:${textId}`);
+    const text = {
+      id: textId,
+      projectId: context.workspace.config.projectId,
+      sourceComment: typeof body.sourceComment === "string" ? body.sourceComment : null,
+      links: Array.isArray(body.links) ? body.links : [],
+      localeValues: {
+        [locale]: {
+          value: body.value,
+          statusId,
+          localeComment: null,
+          updatedAt: now
+        }
+      },
+      createdAt: now,
+      updatedAt: now
+    };
+    const operation = existingHead === void 0 ? "create" : "update";
+    const convex = await createConvexClient(context.workspace);
+    await convex.mutation(api.serverProjectRecordOperations.commitFromSession, {
+      projectId: context.workspace.config.projectId,
+      versionId: context.workspace.config.versionId,
+      operation,
+      changes: [
+        {
+          recordKind: "localized-text",
+          recordId: textId,
+          operation,
+          nextData: text,
+          intent: createProjectVersionIntent(`localized-text.${operation}`, {
+            source: "neo-cli-loc"
+          }),
+          expectedBaseContentHash: existingHead?.contentHash ?? null
+        }
+      ],
+      summary: `neo loc ${operation}`
+    });
+    console.log(textId);
+    return;
+  }
+  if (subcommand === "delete") {
+    const textId = positional[0];
+    if (textId === void 0) {
+      throw new Error("Usage: neo loc delete <textId>");
+    }
+    const { heads } = await fetchProjectDocument(context.workspace);
+    const head = heads.get(`localized-text:${textId}`);
+    if (head === void 0) {
+      throw new Error(`Localized text "${textId}" was not found.`);
+    }
+    const convex = await createConvexClient(context.workspace);
+    await convex.mutation(api.serverProjectRecordOperations.commitFromSession, {
+      projectId: context.workspace.config.projectId,
+      versionId: context.workspace.config.versionId,
+      operation: "delete",
+      changes: [
+        {
+          recordKind: "localized-text",
+          recordId: textId,
+          operation: "delete",
+          deleted: true,
+          intent: createProjectVersionIntent("localized-text.delete", {
+            source: "neo-cli-loc"
+          }),
+          expectedBaseContentHash: head.contentHash
+        }
+      ],
+      summary: "neo loc delete"
+    });
+    console.log(`deleted ${textId}`);
+    return;
+  }
+  if (subcommand === "archive" || subcommand === "restore") {
+    const textId = positional[0];
+    if (textId === void 0) {
+      throw new Error(`Usage: neo loc ${subcommand} <textId>`);
+    }
+    const result = await context.client.post(
+      versionPath(context.workspace, `localized-texts/${textId}/archive/edit`),
+      { archived: subcommand === "archive" }
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
   if (subcommand === "status-set") {
     const [textId, locale, statusId] = positional;
     if (textId === void 0 || locale === void 0 || statusId === void 0) {
@@ -12593,6 +14314,103 @@ async function runDialogue(context, subcommand, positional, file) {
       `Unknown ${subcommand} verb "${String(groupVerb)}" (list | create | edit | delete).`
     );
   }
+  if (subcommand === "create" || subcommand === "edit" || subcommand === "delete") {
+    const readBody = () => {
+      const batch = readBatch(file);
+      if (batch !== null) {
+        throw new Error(
+          `neo dialogue ${subcommand} takes one JSON body, not a batch.`
+        );
+      }
+      const jsonArg = positional[positional.length - 1];
+      if (jsonArg === void 0 || !jsonArg.trim().startsWith("{")) {
+        throw new Error(
+          `Usage: neo dialogue ${subcommand} ${subcommand === "create" ? "'<IDialogueBase json>'" : "<dialogueId> ['<json>']"}${file === null ? " (or --file <path>)" : ""}`
+        );
+      }
+      return JSON.parse(jsonArg);
+    };
+    if (subcommand === "create") {
+      const result2 = await context.client.post(
+        versionPath(context.workspace, "dialogues/create"),
+        readBody()
+      );
+      console.log(JSON.stringify(result2, null, 2));
+      return;
+    }
+    const dialogueId = positional[0];
+    if (dialogueId === void 0) {
+      throw new Error(`Usage: neo dialogue ${subcommand} <dialogueId>`);
+    }
+    const result = await context.client.post(
+      versionPath(context.workspace, `dialogues/${dialogueId}/${subcommand}`),
+      subcommand === "edit" ? readBody() : void 0
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "export") {
+    const ref = positional[0];
+    if (ref === void 0) {
+      throw new Error("Usage: neo dialogue export <dialogueIdOrName>");
+    }
+    const { runDialogueExport: runDialogueExport2 } = await Promise.resolve().then(() => (init_dialogue_spec(), dialogue_spec_exports));
+    await runDialogueExport2(context.workspace, ref);
+    return;
+  }
+  if (subcommand === "apply") {
+    const specFile = file ?? positional[0];
+    if (specFile === void 0) {
+      throw new Error(
+        "Usage: neo dialogue apply <spec.json> [--dry-run] (or --file <path>)"
+      );
+    }
+    const { runDialogueApply: runDialogueApply2 } = await Promise.resolve().then(() => (init_dialogue_spec(), dialogue_spec_exports));
+    await runDialogueApply2(
+      context.workspace,
+      specFile,
+      process.argv.includes("--dry-run")
+    );
+    return;
+  }
+  if (subcommand === "dryrun") {
+    const { runDialogueDryrun: runDialogueDryrun2 } = await Promise.resolve().then(() => (init_dialogue_dryrun(), dialogue_dryrun_exports));
+    await runDialogueDryrun2(
+      context.workspace,
+      positional[0] ?? null,
+      context.json
+    );
+    return;
+  }
+  if (subcommand === "compile") {
+    const jsonArg = positional[0];
+    if (jsonArg === void 0) {
+      throw new Error(
+        `Usage: neo dialogue compile '{"code":"...","target":0|1|2,"node":{"primaryLinkedValueId":...}}'`
+      );
+    }
+    const result = await context.client.post(
+      versionPath(context.workspace, "dialogue-logic/compile"),
+      JSON.parse(jsonArg)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "text") {
+    const dialogueId = positional[0];
+    const jsonArg = positional[1];
+    if (dialogueId === void 0 || jsonArg === void 0) {
+      throw new Error(
+        `Usage: neo dialogue text <dialogueId> '{"nodeId":...,"textId":...,"locale":"en-US","value":...,"variableIds":[]}'`
+      );
+    }
+    const result = await context.client.post(
+      versionPath(context.workspace, `dialogues/${dialogueId}/rich-text/edit`),
+      JSON.parse(jsonArg)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
   if (subcommand === "node") {
     const nodeVerb = positional[0];
     const dialogueId = positional[1];
@@ -12641,10 +14459,110 @@ async function runDialogue(context, subcommand, positional, file) {
     );
   }
   throw new Error(
-    `Unknown dialogue subcommand "${subcommand}" (list | show | node | group | priority-group).`
+    `Unknown dialogue subcommand "${subcommand}" (list | show | export | apply | dryrun | create | edit | delete | text | compile | node | group | priority-group).`
+  );
+}
+async function uploadProjectFile(context, filePath, preferredTemplateId) {
+  const { readFileSync: readFile } = await import("node:fs");
+  const { basename, extname } = await import("node:path");
+  const bytes = readFile(filePath);
+  const name = basename(filePath);
+  const extension = extname(filePath).toLowerCase();
+  const mimeByExtension = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".wav": "audio/wav",
+    ".mp3": "audio/mpeg",
+    ".ogg": "audio/ogg"
+  };
+  const mimeType = mimeByExtension[extension];
+  if (mimeType === void 0) {
+    throw new Error(
+      `Unsupported upload extension "${extension}" (png/jpg/gif/wav/mp3/ogg).`
+    );
+  }
+  const replaceIndex = process.argv.indexOf("--replace");
+  const replaceFileId = replaceIndex >= 0 ? process.argv[replaceIndex + 1] ?? null : null;
+  const projectFileId = replaceFileId ?? randomUUID5();
+  const metadata = { projectFileId };
+  if (preferredTemplateId !== null) {
+    metadata.preferredTemplateId = preferredTemplateId;
+  }
+  if (replaceFileId !== null) {
+    metadata.replaceFileId = replaceFileId;
+  }
+  const presign = await context.client.post(
+    versionPath(context.workspace, "upload"),
+    {
+      route: "projectFile",
+      metadata,
+      files: [{ name, size: bytes.byteLength, type: mimeType }]
+    }
+  );
+  const entries = Array.isArray(presign.files) ? presign.files : [];
+  const entry = entries.filter(isObjectRecord2)[0];
+  if (entry === void 0) {
+    throw new Error("Upload presign returned no files.");
+  }
+  const signedUrl = entry.signedUrl;
+  const fileInfo = isObjectRecord2(entry.file) ? entry.file : {};
+  const objectInfo = isObjectRecord2(fileInfo.objectInfo) ? fileInfo.objectInfo : {};
+  const storageKey = objectInfo.key;
+  if (typeof signedUrl !== "string" || typeof storageKey !== "string") {
+    throw new Error("Upload presign response is missing signedUrl/key.");
+  }
+  const putHeaders = { "Content-Type": mimeType };
+  if (typeof objectInfo.cacheControl === "string") {
+    putHeaders["Cache-Control"] = objectInfo.cacheControl;
+  }
+  if (isObjectRecord2(objectInfo.metadata)) {
+    for (const [key, value] of Object.entries(objectInfo.metadata)) {
+      if (typeof value === "string") putHeaders[`x-amz-meta-${key}`] = value;
+    }
+  }
+  if (isObjectRecord2(entry.headers)) {
+    for (const [key, value] of Object.entries(entry.headers)) {
+      if (typeof value === "string") putHeaders[key] = value;
+    }
+  }
+  const putResponse = await fetch(signedUrl, {
+    method: "PUT",
+    headers: putHeaders,
+    body: new Uint8Array(bytes)
+  });
+  if (!putResponse.ok) {
+    throw new Error(
+      `Storage PUT failed (${putResponse.status}): ${await putResponse.text()}`
+    );
+  }
+  const finalized = await context.client.post(
+    versionPath(context.workspace, "files/finalize-upload"),
+    {
+      projectFileId,
+      replaceFileId,
+      name,
+      mimeType,
+      byteLength: bytes.byteLength,
+      storageKey
+    }
   );
+  console.log(JSON.stringify(finalized, null, 2));
 }
 async function runFiles(context, subcommand, positional) {
+  if (subcommand === "upload") {
+    const filePath = positional[0];
+    if (filePath === void 0) {
+      throw new Error(
+        "Usage: neo files upload <path> [--template <templateId>] [--replace <fileId>]"
+      );
+    }
+    const templateIndex = process.argv.indexOf("--template");
+    const preferredTemplateId = templateIndex >= 0 ? process.argv[templateIndex + 1] ?? null : null;
+    await uploadProjectFile(context, filePath, preferredTemplateId);
+    return;
+  }
   if (subcommand === "list") {
     const { raw } = await fetchProjectDocument(context.workspace);
     const projectFiles = Array.isArray(raw.projectFiles) ? raw.projectFiles.filter(isObjectRecord2) : [];
@@ -12671,8 +14589,25 @@ async function runFiles(context, subcommand, positional) {
     console.log(JSON.stringify(result, null, 2));
     return;
   }
+  if (subcommand === "texture-settings") {
+    const fileId = positional[0];
+    const fileFlagIndex = process.argv.indexOf("--file");
+    const payloadPath = fileFlagIndex >= 0 ? process.argv[fileFlagIndex + 1] ?? null : null;
+    if (fileId === void 0 || payloadPath === null) {
+      throw new Error(
+        "Usage: neo files texture-settings <fileId> --file <settings.json>"
+      );
+    }
+    const payload = JSON.parse(readFileSync10(payloadPath, "utf8"));
+    const result = await context.client.post(
+      versionPath(context.workspace, `files/${fileId}/unity-texture-settings`),
+      payload
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
   throw new Error(
-    `Unknown files subcommand "${subcommand}" (list | delete; upload remains a web/Unity flow).`
+    `Unknown files subcommand "${subcommand}" (upload | list | delete | texture-settings).`
   );
 }
 var init_content = __esm({
@@ -12686,13 +14621,64 @@ var init_content = __esm({
   }
 });
 
+// src/commands/export.ts
+var export_exports = {};
+__export(export_exports, {
+  runExportUnity: () => runExportUnity
+});
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+async function runExportUnity(workspace, outDir) {
+  if (outDir === null) {
+    throw new Error(
+      "Usage: neo export unity --out <UnityAssetsDir> (the Unity project's Assets folder)"
+    );
+  }
+  const client = NeoApiClient.forBaseUrl(workspace.config.apiBaseUrl);
+  const response = await client.post(
+    `/api/projects/${workspace.config.projectId}/export`,
+    { versionId: workspace.config.versionId }
+  );
+  const resourcesDir = join10(outDir, "Resources", "Neo");
+  const localizationDir = join10(resourcesDir, "Localization");
+  const scriptsDir = join10(outDir, "Scripts", "Neo");
+  mkdirSync8(localizationDir, { recursive: true });
+  mkdirSync8(scriptsDir, { recursive: true });
+  writeFileSync8(join10(resourcesDir, "project.json"), response.projectJson);
+  writeFileSync8(
+    join10(scriptsDir, "NeoGeneratedTypes.cs"),
+    response.generatedTypes
+  );
+  for (const file of response.localizationFiles ?? []) {
+    writeFileSync8(join10(localizationDir, file.fileName), file.content);
+  }
+  console.log(`wrote ${join10(resourcesDir, "project.json")}`);
+  console.log(`wrote ${join10(scriptsDir, "NeoGeneratedTypes.cs")}`);
+  for (const file of response.localizationFiles ?? []) {
+    console.log(`wrote ${join10(localizationDir, file.fileName)}`);
+  }
+  const diagnostics = response.diagnostics ?? [];
+  for (const diagnostic of diagnostics) {
+    console.log(`${diagnostic.severity}: ${diagnostic.message}`);
+  }
+  if (diagnostics.length === 0) {
+    console.log("no export diagnostics");
+  }
+}
+var init_export = __esm({
+  "src/commands/export.ts"() {
+    "use strict";
+    init_http();
+  }
+});
+
 // src/commands/dev.ts
 var dev_exports = {};
 __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -12795,7 +14781,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Attributes", "Enums"]) {
     try {
-      watch(join10(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join11(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -12880,13 +14866,19 @@ var EDITOR_SCOPES = [
   "project:localization:values:write",
   "project:localization:export",
   "project:localization:import",
-  "project:release-channel:read"
+  "project:release-channel:read",
+  // `neo export unity` writes project.json + NeoGeneratedTypes.cs headlessly
+  // (the escape hatch when game code references not-yet-generated members and
+  // a broken compile blocks the in-editor sync).
+  "unity:export",
+  // Branch lifecycle (auto-archive after `neo merge`, branch archive/restore)
+  // is editor work; releases stay gated behind the release profile.
+  "project:version:archive",
+  "project:version:restore"
 ];
 var RELEASE_SCOPES = [
   ...EDITOR_SCOPES,
   "project:version:status:write",
-  "project:version:archive",
-  "project:version:restore",
   "project:release-channel:write",
   "project:release-channel:publish"
 ];
@@ -13103,6 +15095,12 @@ namespace NeoCompose.Schema
         public string? Name { get; set; }
         public string? ExtendsId { get; set; }
         public bool Locked { get; set; }
+        /// <summary>
+        /// Storage class override: "static", "save", or "session". Absent
+        /// means the attribute inherits its placement parent's storage
+        /// (specs/attribute-storage.md).
+        /// </summary>
+        public string? Storage { get; set; }
         public string? DefaultJson { get; set; }
         public string? ExtraJson { get; set; }
         protected NeoSchemaMemberAttribute(string? id) { Id = id; }
@@ -13115,6 +15113,11 @@ namespace NeoCompose.Schema
         public string? Name { get; set; }
         public string? ExtendsTypeId { get; set; }
         public bool Hidden { get; set; }
+        /// <summary>
+        /// Placement constraint: "static", "save", or "session". Absent
+        /// means the type may be placed at any storage class.
+        /// </summary>
+        public string? AllowedStorage { get; set; }
         public string? ExtraJson { get; set; }
         public NeoCustomTypeAttribute(string? id = null) { Id = id; }
         public string? Id { get; }
@@ -13172,6 +15175,30 @@ namespace NeoCompose.Schema
         public NeoStringAttribute(string? id = null) : base(id) { }
     }
 
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class NeoVector2Attribute : NeoSchemaMemberAttribute
+    {
+        public NeoVector2Attribute(string? id = null) : base(id) { }
+    }
+
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class NeoVector2IntAttribute : NeoSchemaMemberAttribute
+    {
+        public NeoVector2IntAttribute(string? id = null) : base(id) { }
+    }
+
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class NeoVector3Attribute : NeoSchemaMemberAttribute
+    {
+        public NeoVector3Attribute(string? id = null) : base(id) { }
+    }
+
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class NeoVector3IntAttribute : NeoSchemaMemberAttribute
+    {
+        public NeoVector3IntAttribute(string? id = null) : base(id) { }
+    }
+
     [AttributeUsage(AttributeTargets.Property)]
     public sealed class NeoDictionaryAttribute : NeoSchemaMemberAttribute
     {
@@ -13266,6 +15293,10 @@ namespace NeoCompose.Schema
     public sealed class NeoAudioValue { }
     public sealed class NeoFunctionValue { }
     public sealed class NeoLookupRef { }
+    public sealed class NeoVector2 { }
+    public sealed class NeoVector2Int { }
+    public sealed class NeoVector3 { }
+    public sealed class NeoVector3Int { }
 }
 `;
 function scaffoldWorkspace(root) {
@@ -13502,7 +15533,7 @@ ${h("Branches & releases")}
   channel   ${d("list | create | edit | delete")}
 
 ${h("Content & scripts")}
-  values    ${d("list | get | set")}          loc       ${d("locales | list | set | status-set | comment-set")}
+  values    ${d("list | get | set")}          loc       ${d("locales | list | set | archive | restore | ...")}
   dialogue  ${d("list | show | node | group | priority-group")}
   records   ${d("get | query")}               files     ${d("list | delete")}
   script    ${d("check | eval | apply")}      migrate   ${d("new | list | check | run | prune")}
@@ -13681,12 +15712,22 @@ async function main() {
       }
       return;
     }
+    case "export": {
+      const workspace = loadWorkspace(process.cwd());
+      const sub = args.positional[0];
+      if (sub !== "unity") {
+        throw new Error("neo export requires a subcommand: unity.");
+      }
+      const { runExportUnity: runExportUnity2 } = await Promise.resolve().then(() => (init_export(), export_exports));
+      await runExportUnity2(workspace, stringFlag(args, "out"));
+      return;
+    }
     case "script": {
       const workspace = loadWorkspace(process.cwd());
       const sub = args.positional[0];
-      if (sub !== "check" && sub !== "eval" && sub !== "apply") {
+      if (sub !== "check" && sub !== "eval" && sub !== "apply" && sub !== "compile") {
         throw new Error(
-          "neo script requires a subcommand: check | eval | apply."
+          "neo script requires a subcommand: check | eval | apply | compile."
         );
       }
       const { runScript: runScript2 } = await Promise.resolve().then(() => (init_script(), script_exports));