@neocompose/cli 0.68.0 → 0.68.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.68.1] - 2026-10-05
+
+- An override of a generic class's function, as in `protected override int Apply(int next)` in a class that extends `ValueWatcher<int>`, checks its compiled body against the signature its class closes. Before, export and publish failed with "NSFunction action parameter 0 type does not match its public signature." An override can also close the param with a List, as in `Picker<List<int>>`, or forward it to its own class's param, as in `class Forward<V> : Watch<V>` or `Picker<Box<V>>`, or bind it to a multiselect enum, as in `Picker<Set<Mood>>`. A base constructor argument can forward a param inside a binding, as in `: Watch<Box<V>>(initial: initial)`, and a base bound to `Set<Mood>` takes a set. A multiselect enum member no longer satisfies an interface property typed as a single enum. Before, push failed with "compiled action return type is stale." or "Returned Box<V> is not assignable to declared return type Box".
+
 ## [0.68.0] - 2026-10-04
 
 - Author member subscriptions with `value.Field.OnChanged += handler` and `-=`, and persist wiring with `@listeners(Field: [handler])`. Listener arguments must be named; multiple fields may appear in any order.

package/dist/neo.mjs

@@ -31193,7 +31193,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.68.0",
+      cliVersion: "0.68.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -47792,30 +47792,118 @@ function substituteMember(member, env, members, preResolvedMember) {
   return resolved;
 }
 function substituteNestedTypeInfo(typeInfo, env, members) {
-  if (typeInfo.type === 21 /* Generic */) {
-    const entry = env.get(typeInfo.genericParamId);
+  return mapGenericTypeInfo(typeInfo, (generic) => {
+    const entry = env.get(generic.genericParamId);
     if (entry === void 0) {
       throw new Error(
-        `substituteMember: callable type references generic param "${typeInfo.genericParamId}", which is not present in the binding environment.`
+        `substituteMember: callable type references generic param "${generic.genericParamId}", which is not present in the binding environment.`
       );
     }
-    if (entry.kind === "unbound") return typeInfo;
-    const binding = memberIndexFor(members).get(entry.memberId);
-    if (binding === void 0) {
-      throw new Error(
-        `substituteMember: callable type binding member "${entry.memberId}" for generic param "${typeInfo.genericParamId}" does not exist in the document.`
-      );
+    if (entry.kind === "unbound") return generic;
+    return genericBindingTypeInfo(
+      callableBindingMember(entry.memberId, generic.genericParamId, members),
+      env,
+      members
+    );
+  });
+}
+function substituteInheritedCallableTypeInfo(typeInfo, env, classes, members) {
+  return mapGenericTypeInfo(typeInfo, (generic) => {
+    const entry = env.get(generic.genericParamId);
+    if (entry === void 0) return generic;
+    if (entry.kind === "unbound") {
+      const forwarded = forwardedParamTypeInfo(entry.paramId, classes);
+      return forwarded === null ? generic : { ...forwarded, required: generic.required };
     }
-    return genericBindingTypeInfo(binding, env, members);
+    const bound = openBindingTypeInfo(
+      callableBindingMember(entry.memberId, generic.genericParamId, members),
+      env,
+      classes,
+      members
+    );
+    return { ...bound, required: bound.required && generic.required };
+  });
+}
+function forwardedParamTypeInfo(genericParamId, classes) {
+  const declaration = findGenericParamDeclaration(genericParamId, classes);
+  if (declaration === null) return null;
+  return {
+    type: 21 /* Generic */,
+    required: true,
+    ownerClassId: declaration.declaringClass.id,
+    genericParamId
+  };
+}
+function openBindingTypeInfo(member, env, classes, members) {
+  const resolved = resolveMember(member, members);
+  const nested = (memberId) => openBindingTypeInfo(
+    callableBindingMember(memberId, resolved.name, members),
+    env,
+    classes,
+    members
+  );
+  const param = (genericParamId) => {
+    const entry = env.get(genericParamId);
+    if (entry?.kind === "member") return nested(entry.memberId);
+    if (entry?.kind === "unbound") {
+      return forwardedParamTypeInfo(entry.paramId, classes);
+    }
+    return null;
+  };
+  if (isMemberGenericBase(resolved)) {
+    return param(resolved.genericParamId) ?? genericBindingTypeInfo(resolved, env, members);
   }
+  const required2 = isRequiredMember2(resolved);
+  if (isMemberClassBase(resolved)) {
+    const typeArguments = {};
+    for (const [parameterId, argument2] of Object.entries(
+      resolved.classArguments ?? {}
+    )) {
+      const argumentType = isForwardedGenericBinding(argument2) ? param(argument2.genericParamId) : nested(argument2.memberId);
+      if (argumentType === null) {
+        return genericBindingTypeInfo(resolved, env, members);
+      }
+      typeArguments[parameterId] = argumentType;
+    }
+    return {
+      type: 7 /* Class */,
+      required: required2,
+      classId: resolved.classId,
+      ...Object.keys(typeArguments).length === 0 ? {} : { typeArguments }
+    };
+  }
+  if (isMemberListBase(resolved)) {
+    return {
+      type: 6 /* List */,
+      required: required2,
+      entryTypeInfo: nested(resolved.entryMemberId)
+    };
+  }
+  if (isMemberDictionaryBase(resolved)) {
+    return {
+      type: 5 /* Dictionary */,
+      required: required2,
+      entryTypeInfo: nested(resolved.entryMemberId),
+      ...resolved.keyEnumId == null ? {} : { keyEnumId: resolved.keyEnumId }
+    };
+  }
+  return genericBindingTypeInfo(resolved, env, members);
+}
+function callableBindingMember(memberId, slotName, members) {
+  const binding = memberIndexFor(members).get(memberId);
+  if (binding === void 0) {
+    throw new Error(
+      `substituteMember: callable type binding member "${memberId}" for "${slotName}" does not exist in the document.`
+    );
+  }
+  return binding;
+}
+function mapGenericTypeInfo(typeInfo, close) {
+  if (typeInfo.type === 21 /* Generic */) return close(typeInfo);
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
     return {
       ...typeInfo,
-      entryTypeInfo: substituteNestedTypeInfo(
-        typeInfo.entryTypeInfo,
-        env,
-        members
-      )
+      entryTypeInfo: mapGenericTypeInfo(typeInfo.entryTypeInfo, close)
     };
   }
   if (typeInfo.type === 7 /* Class */) {
@@ -47826,7 +47914,7 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
       typeArguments: Object.fromEntries(
         Object.entries(typeArguments).map(([parameterId, argument2]) => [
           parameterId,
-          substituteNestedTypeInfo(argument2, env, members)
+          mapGenericTypeInfo(argument2, close)
         ])
       )
     };
@@ -47834,13 +47922,9 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
   if (typeInfo.type === 25 /* NSDelegate */) {
     return {
       ...typeInfo,
-      returnTypeInfo: substituteNestedTypeInfo(
-        typeInfo.returnTypeInfo,
-        env,
-        members
-      ),
+      returnTypeInfo: mapGenericTypeInfo(typeInfo.returnTypeInfo, close),
       argumentTypes: typeInfo.argumentTypes.map(
-        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+        (argument2) => mapGenericTypeInfo(argument2, close)
       )
     };
   }
@@ -47848,7 +47932,7 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
     return {
       ...typeInfo,
       argumentTypes: typeInfo.argumentTypes.map(
-        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+        (argument2) => mapGenericTypeInfo(argument2, close)
       )
     };
   }
@@ -47880,11 +47964,16 @@ function typeInfoFromArgumentSignature(signature) {
   }
   if (signature.type === 8 /* Enum */) {
     const enumSignature = signature;
-    return {
+    const enumTypeInfo = {
       type: 8 /* Enum */,
       required: enumSignature.required,
       enumId: enumSignature.enumId
     };
+    return enumSignature.multiselect ? {
+      type: 9 /* Lookup */,
+      required: enumSignature.required,
+      entryTypeInfo: { ...enumTypeInfo, required: true }
+    } : enumTypeInfo;
   }
   if (signature.type === 6 /* List */) {
     const listSignature = signature;
@@ -88142,6 +88231,7 @@ function compileConstructorBaseArguments(args, owner) {
     deleteRecordField(args.constructor, "compiledBaseArguments");
     return;
   }
+  const ownerEnv = resolveGenericEnv(owner.id, args.classes);
   const compiledBaseArguments = baseArguments.map(
     (baseArgument) => {
       const parameter4 = baseConstructor.argumentTypes.find(
@@ -88152,10 +88242,11 @@ function compileConstructorBaseArguments(args, owner) {
           `Constructor "${args.constructor.id}" binds base argument "${baseArgument.name}", which base constructor "${baseConstructor.id}" does not declare.`
         );
       }
-      const returnTypeInfo = substituteConstructorBaseType(
+      const returnTypeInfo = substituteInheritedCallableTypeInfo(
         parameter4,
-        owner,
-        args
+        ownerEnv,
+        args.classes,
+        args.members
       );
       return compileUnit2(
         "getter",
@@ -88171,73 +88262,6 @@ function compileConstructorBaseArguments(args, owner) {
   );
   Object.assign(args.constructor, { compiledBaseArguments });
 }
-function substituteConstructorBaseType(typeInfo, owner, args) {
-  if (typeInfo.type === 21 /* Generic */) {
-    const binding = resolveGenericEnv(owner.id, args.classes).get(
-      typeInfo.genericParamId
-    );
-    if (binding === void 0) return typeInfo;
-    if (binding.kind === "unbound") {
-      return {
-        ...typeInfo,
-        ownerClassId: owner.id,
-        genericParamId: binding.paramId
-      };
-    }
-    const member = args.members.find(
-      (candidate) => candidate.id === binding.memberId
-    );
-    if (member === void 0) {
-      throw new Error(
-        `Constructor "${args.constructor.id}" resolves generic parameter "${typeInfo.genericParamId}" to missing member "${binding.memberId}".`
-      );
-    }
-    return resolveMemberDeclaredTypeInfo(member, args.members) ?? typeInfo;
-  }
-  if (typeInfo.type === 25 /* NSDelegate */) {
-    return {
-      ...typeInfo,
-      returnTypeInfo: substituteConstructorBaseType(
-        typeInfo.returnTypeInfo,
-        owner,
-        args
-      ),
-      argumentTypes: typeInfo.argumentTypes.map(
-        (argument2) => substituteConstructorBaseType(argument2, owner, args)
-      )
-    };
-  }
-  if (typeInfo.type === 26 /* NSAction */) {
-    return {
-      ...typeInfo,
-      argumentTypes: typeInfo.argumentTypes.map(
-        (argument2) => substituteConstructorBaseType(argument2, owner, args)
-      )
-    };
-  }
-  if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
-    return {
-      ...typeInfo,
-      entryTypeInfo: substituteConstructorBaseType(
-        typeInfo.entryTypeInfo,
-        owner,
-        args
-      )
-    };
-  }
-  if (typeInfo.type !== 7 /* Class */ || typeInfo.typeArguments === void 0) {
-    return typeInfo;
-  }
-  return {
-    ...typeInfo,
-    typeArguments: Object.fromEntries(
-      Object.entries(typeInfo.typeArguments).map(([parameterId, argument2]) => [
-        parameterId,
-        substituteConstructorBaseType(argument2, owner, args)
-      ])
-    )
-  };
-}
 function compileConstructorBaseInitializerFields(args, owner) {
   const fields = args.constructor.baseInitializerFields ?? [];
   if (fields.length === 0) {
@@ -109030,6 +109054,19 @@ function stableValue(value) {
 function stableTypeInfo(value) {
   return JSON.stringify(stableValue(value));
 }
+function callableTypeIdentity(value) {
+  return stableTypeInfo(withoutListCapability(value));
+}
+function withoutListCapability(value) {
+  if (Array.isArray(value)) return value.map(withoutListCapability);
+  if (!isRecord7(value)) return value;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "listMemberId") continue;
+    result[key] = withoutListCapability(entry);
+  }
+  return result;
+}
 function isOpaqueGeneratedIdentifier(value, neoPredicate) {
   return typeof value === "string" && neoPredicate(value) && isGeneratedCSharpIdentifier(value) && !isGeneratedCSharpReservedKeyword(value);
 }
@@ -110039,6 +110076,16 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     inspectValueBody(syntheticMember2, value.value, value.classId);
   }
   function genericEnvForClass(schemaClass2) {
+    const env = /* @__PURE__ */ new Map();
+    for (const [paramId, binding] of genericBindingsForClass(schemaClass2)) {
+      env.set(
+        paramId,
+        binding.kind === 1 /* Member */ ? binding.memberId : null
+      );
+    }
+    return env;
+  }
+  function genericBindingsForClass(schemaClass2) {
     const chain = [];
     const seen = /* @__PURE__ */ new Set();
     let current = schemaClass2;
@@ -110047,25 +110094,26 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       chain.push(current);
       current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
     }
-    const env = /* @__PURE__ */ new Map();
+    const bindings = /* @__PURE__ */ new Map();
     for (let declarerIndex = 0; declarerIndex < chain.length; declarerIndex += 1) {
       for (const param of chain[declarerIndex]?.genericParams ?? []) {
         let cursor = param.id;
-        let terminalMemberId = null;
+        let terminal2 = {
+          kind: 0 /* Generic */,
+          genericParamId: cursor
+        };
         for (let level = declarerIndex; level > 0; level -= 1) {
           const child2 = chain[level - 1];
           const binding = child2?.extendsGenericBindings?.[cursor];
           if (!binding) break;
-          if (binding.kind === 1 /* Member */) {
-            terminalMemberId = binding.memberId;
-            break;
-          }
+          terminal2 = binding;
+          if (binding.kind === 1 /* Member */) break;
           cursor = binding.genericParamId;
         }
-        env.set(param.id, terminalMemberId);
+        bindings.set(param.id, terminal2);
       }
     }
-    return env;
+    return bindings;
   }
   function substituteMemberForClass(member, schemaClass2) {
     const resolved = resolveMember4(member);
@@ -110102,7 +110150,10 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     const resolved = substituteMemberForClass(member, schemaClass2);
     const required2 = isRequiredMember2(resolved);
     if (resolved.kind === 10) return resolved.returnTypeInfo ?? null;
-    if (resolved.kind === 13 || resolved.kind === 21 || resolved.kind === 22 || resolved.kind === 23) {
+    if (resolved.kind === 21) {
+      return typeof resolved.genericParamId === "string" ? forwardedGenericTypeInfo(resolved.genericParamId, schemaClass2) : null;
+    }
+    if (resolved.kind === 13 || resolved.kind === 22 || resolved.kind === 23) {
       return null;
     }
     if (resolved.kind === 7) {
@@ -110111,7 +110162,15 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       for (const [paramId, binding] of Object.entries(
         resolved.classArguments ?? {}
       )) {
-        if (binding.kind !== 1 /* Member */) return null;
+        if (binding.kind !== 1 /* Member */) {
+          const forwarded = forwardedGenericTypeInfo(
+            binding.genericParamId,
+            schemaClass2
+          );
+          if (!forwarded) return null;
+          typeArguments[paramId] = forwarded;
+          continue;
+        }
         const bindingMember = membersById.get(binding.memberId);
         if (!bindingMember) return null;
         const bindingTypeInfo = memberTypeInfo(
@@ -110130,7 +110189,12 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       };
     }
     if (resolved.kind === 8) {
-      return typeof resolved.enumId === "string" ? { type: 8, required: required2, enumId: resolved.enumId } : null;
+      if (typeof resolved.enumId !== "string") return null;
+      return resolved.selection === 1 /* Multi */ ? {
+        type: 9,
+        required: required2,
+        entryTypeInfo: { type: 8, required: true, enumId: resolved.enumId }
+      } : { type: 8, required: required2, enumId: resolved.enumId };
     }
     if (resolved.kind === 5 || resolved.kind === 6) {
       if (typeof resolved.entryMemberId !== "string") return null;
@@ -110234,13 +110298,36 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       genericParamId: resolved.genericParamId
     });
   };
+  const forwardedGenericTypeInfo = (genericParamId, schemaClass2) => {
+    const terminal2 = genericBindingsForClass(schemaClass2).get(genericParamId);
+    if (terminal2 === void 0) return null;
+    if (terminal2.kind === 1 /* Member */) return null;
+    const ownerClassId = genericParamDeclarationsById.get(
+      terminal2.genericParamId
+    )?.ownerClassId;
+    if (ownerClassId === void 0) return null;
+    return {
+      type: 21,
+      required: true,
+      ownerClassId,
+      genericParamId: terminal2.genericParamId
+    };
+  };
   const substituteTypeInfoForClass = (typeInfo, schemaClass2) => {
     if (!isRecord7(typeInfo)) return typeInfo;
     if (typeInfo.type === 21 && typeof typeInfo.genericParamId === "string") {
-      const bindingId = genericEnvForClass(schemaClass2).get(
+      const terminal2 = genericBindingsForClass(schemaClass2).get(
         typeInfo.genericParamId
       );
-      const binding = bindingId ? membersById.get(bindingId) : void 0;
+      if (terminal2 === void 0) return typeInfo;
+      if (terminal2.kind !== 1 /* Member */) {
+        const forwarded = forwardedGenericTypeInfo(
+          typeInfo.genericParamId,
+          schemaClass2
+        );
+        return forwarded ? { ...forwarded, required: typeInfo.required === true } : typeInfo;
+      }
+      const binding = membersById.get(terminal2.memberId);
       const boundType = binding ? memberTypeInfo(binding, schemaClass2) : null;
       return isRecord7(boundType) ? {
         ...boundType,
@@ -110496,7 +110583,7 @@ function assertOpaqueCompiledNSFunctionAction(member, signature, typeInfoInDecla
       `NSFunction "${member.id}" Void return type must be required.`
     );
   }
-  if (stableTypeInfo(member.action.typeInfo) !== stableTypeInfo(typeInfoInDeclaringClass(normalizedReturnType2))) {
+  if (callableTypeIdentity(member.action.typeInfo) !== callableTypeIdentity(typeInfoInDeclaringClass(normalizedReturnType2))) {
     throw new Error(
       `NSFunction "${member.id}" compiled action return type is stale.`
     );
@@ -110524,7 +110611,7 @@ function assertOpaqueCompiledNSFunctionAction(member, signature, typeInfoInDecla
         `NSFunction "${member.id}" compiled action parameter ${index + 1} is stale.`
       );
     }
-    if (!isRecord7(parameter4.typeInfo) || stableTypeInfo(parameter4.typeInfo) !== stableTypeInfo(
+    if (!isRecord7(parameter4.typeInfo) || callableTypeIdentity(parameter4.typeInfo) !== callableTypeIdentity(
       typeInfoInDeclaringClass(signature.argumentTypes[index])
     )) {
       throw new Error(
@@ -164154,7 +164241,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.68.0");
+    console.log("0.68.1");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/dist/test-worker.mjs

@@ -7975,30 +7975,36 @@ function substituteMember(member, env, members, preResolvedMember) {
   return resolved;
 }
 function substituteNestedTypeInfo(typeInfo, env, members) {
-  if (typeInfo.type === 21 /* Generic */) {
-    const entry = env.get(typeInfo.genericParamId);
+  return mapGenericTypeInfo(typeInfo, (generic) => {
+    const entry = env.get(generic.genericParamId);
     if (entry === void 0) {
       throw new Error(
-        `substituteMember: callable type references generic param "${typeInfo.genericParamId}", which is not present in the binding environment.`
-      );
-    }
-    if (entry.kind === "unbound") return typeInfo;
-    const binding = memberIndexFor(members).get(entry.memberId);
-    if (binding === void 0) {
-      throw new Error(
-        `substituteMember: callable type binding member "${entry.memberId}" for generic param "${typeInfo.genericParamId}" does not exist in the document.`
+        `substituteMember: callable type references generic param "${generic.genericParamId}", which is not present in the binding environment.`
       );
     }
-    return genericBindingTypeInfo(binding, env, members);
+    if (entry.kind === "unbound") return generic;
+    return genericBindingTypeInfo(
+      callableBindingMember(entry.memberId, generic.genericParamId, members),
+      env,
+      members
+    );
+  });
+}
+function callableBindingMember(memberId, slotName, members) {
+  const binding = memberIndexFor(members).get(memberId);
+  if (binding === void 0) {
+    throw new Error(
+      `substituteMember: callable type binding member "${memberId}" for "${slotName}" does not exist in the document.`
+    );
   }
+  return binding;
+}
+function mapGenericTypeInfo(typeInfo, close) {
+  if (typeInfo.type === 21 /* Generic */) return close(typeInfo);
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
     return {
       ...typeInfo,
-      entryTypeInfo: substituteNestedTypeInfo(
-        typeInfo.entryTypeInfo,
-        env,
-        members
-      )
+      entryTypeInfo: mapGenericTypeInfo(typeInfo.entryTypeInfo, close)
     };
   }
   if (typeInfo.type === 7 /* Class */) {
@@ -8009,7 +8015,7 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
       typeArguments: Object.fromEntries(
         Object.entries(typeArguments).map(([parameterId, argument2]) => [
           parameterId,
-          substituteNestedTypeInfo(argument2, env, members)
+          mapGenericTypeInfo(argument2, close)
         ])
       )
     };
@@ -8017,13 +8023,9 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
   if (typeInfo.type === 25 /* NSDelegate */) {
     return {
       ...typeInfo,
-      returnTypeInfo: substituteNestedTypeInfo(
-        typeInfo.returnTypeInfo,
-        env,
-        members
-      ),
+      returnTypeInfo: mapGenericTypeInfo(typeInfo.returnTypeInfo, close),
       argumentTypes: typeInfo.argumentTypes.map(
-        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+        (argument2) => mapGenericTypeInfo(argument2, close)
       )
     };
   }
@@ -8031,7 +8033,7 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
     return {
       ...typeInfo,
       argumentTypes: typeInfo.argumentTypes.map(
-        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+        (argument2) => mapGenericTypeInfo(argument2, close)
       )
     };
   }
@@ -8063,11 +8065,16 @@ function typeInfoFromArgumentSignature(signature) {
   }
   if (signature.type === 8 /* Enum */) {
     const enumSignature = signature;
-    return {
+    const enumTypeInfo = {
       type: 8 /* Enum */,
       required: enumSignature.required,
       enumId: enumSignature.enumId
     };
+    return enumSignature.multiselect ? {
+      type: 9 /* Lookup */,
+      required: enumSignature.required,
+      entryTypeInfo: { ...enumTypeInfo, required: true }
+    } : enumTypeInfo;
   }
   if (signature.type === 6 /* List */) {
     const listSignature = signature;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.68.0",
+  "version": "0.68.1",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.68.0 -->
+<!-- reviewed-through-cli: 0.68.1 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -110,7 +110,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.68.0 -->
+<!-- reviewed-through-cli: 0.68.1 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale