@neocompose/cli 0.82.3 → 0.82.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.82.4
+
+### Patch Changes
+
+- 8ce5b54: Accept Reference<T> constructor and method parameters during record validation, including enum and scalar slots. Invalid callable parameters now report the parameter name and validation cause.
+
 ## 0.82.3
 
 ### Patch Changes

package/dist/neo-runtime.mjs

@@ -15508,7 +15508,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.82.3",
+      cliVersion: "0.82.4",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -128632,6 +128632,8 @@ function typeInfoInterfaceIds(value) {
   }
   if ("entryTypeInfo" in value)
     ids.push(...typeInfoInterfaceIds(value.entryTypeInfo));
+  if ("targetTypeInfo" in value)
+    ids.push(...typeInfoInterfaceIds(value.targetTypeInfo));
   if (isRecord8(value.typeArguments)) {
     for (const argument2 of Object.values(value.typeArguments)) {
       ids.push(...typeInfoInterfaceIds(argument2));
@@ -128711,6 +128713,15 @@ function isOpaqueNSTypeInfo(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value.type === 22) {
     return typeof value.interfaceId === "string" && value.interfaceId.length > 0;
   }
+  if (value.type === 29 /* Reference */) {
+    if (ancestors.has(value)) return false;
+    ancestors.add(value);
+    try {
+      return isOpaqueNSTypeInfo(value.targetTypeInfo, ancestors);
+    } finally {
+      ancestors.delete(value);
+    }
+  }
   if (value.type === 25) {
     if (!Array.isArray(value.argumentTypes) || ancestors.has(value)) {
       return false;
@@ -128750,6 +128761,9 @@ function isOpaqueNSTypeInfo(value, ancestors = /* @__PURE__ */ new Set()) {
 }
 function opaqueTypeInfoContainsUnknown(value) {
   if (value.type === "Unknown") return true;
+  if (value.type === 29 /* Reference */) {
+    return isRecord8(value.targetTypeInfo) && opaqueTypeInfoContainsUnknown(value.targetTypeInfo);
+  }
   if (value.type === 5 /* Dictionary */ || value.type === 6 /* List */ || value.type === 28 /* Set */ || value.type === 9 /* Lookup */) {
     return isRecord8(value.entryTypeInfo) && opaqueTypeInfoContainsUnknown(value.entryTypeInfo);
   }
@@ -128838,6 +128852,7 @@ function opaqueFunctionGenericReference(value, matches) {
   }
   const children = [
     value.entryTypeInfo,
+    value.targetTypeInfo,
     value.returnTypeInfo,
     ...Array.isArray(value.argumentTypes) ? value.argumentTypes : [],
     ...isRecord8(value.typeArguments) ? Object.values(value.typeArguments) : []
@@ -128855,7 +128870,38 @@ function isOpaqueNSFunctionReturnTypeInfo(value) {
   return isOpaqueNSTypeInfo(value);
 }
 function isOpaqueCallableArgumentTypeInfo(value) {
-  return isOpaqueNSTypeInfo(value) && isOpaqueCallableArgumentIdentifier(value.name) && !opaqueTypeInfoContainsUnknown(value) && hasValidOpaqueParameterDefault(value);
+  return opaqueCallableArgumentError(value) === null;
+}
+function opaqueCallableArgumentError(value) {
+  if (!isRecord8(value)) return "must be an argument type object.";
+  const { type, required: required2 } = value;
+  if (!isOpaqueNSTypeInfo(value)) {
+    if (type === 29 /* Reference */) {
+      if (typeof required2 !== "boolean") {
+        return "Reference required must be a boolean.";
+      }
+      return "Reference targetTypeInfo is invalid.";
+    }
+    return "type information is invalid.";
+  }
+  if (!isOpaqueCallableArgumentIdentifier(value.name)) {
+    return "name is invalid or reserved.";
+  }
+  if (opaqueTypeInfoContainsUnknown(value)) {
+    return "type contains Unknown.";
+  }
+  if (!hasValidOpaqueParameterDefault(value)) {
+    return "defaultValue is invalid for its type.";
+  }
+  return null;
+}
+function assertOpaqueCallableArgumentsValid(arguments_, owner) {
+  for (const [index, argument2] of arguments_.entries()) {
+    const error = opaqueCallableArgumentError(argument2);
+    if (error === null) continue;
+    const label = isRecord8(argument2) && typeof argument2.name === "string" ? `"${argument2.name}"` : `at index ${index}`;
+    throw new Error(`${owner} parameter ${label} ${error}`);
+  }
 }
 function hasValidOpaqueParameterDefault(value) {
   const wrapper = value.defaultValue;
@@ -128914,7 +128960,7 @@ function assertOpaqueParameterDefaultsValid(member) {
   for (const argument2 of argumentTypes) {
     if (!isRecord8(argument2) || !hasValidOpaqueParameterDefault(argument2)) {
       throw new Error(
-        `Function "${member.name}" (${member.id}) declares a parameter default value that does not match the parameter's type.`
+        `Function "${member.name}" (${member.id}) parameter "${isRecord8(argument2) ? String(argument2.name) : "<invalid>"}" defaultValue is invalid for its type.`
       );
     }
     parameters.push(argument2);
@@ -129756,6 +129802,15 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
         )
       };
     }
+    if (typeInfo.type === 29 /* Reference */) {
+      return {
+        ...typeInfo,
+        targetTypeInfo: substituteTypeInfoForClass(
+          typeInfo.targetTypeInfo,
+          schemaClass2
+        )
+      };
+    }
     if (typeInfo.type === 25 && Array.isArray(typeInfo.argumentTypes)) {
       return {
         ...typeInfo,
@@ -130224,11 +130279,10 @@ function assertOpaqueConstructorValid(declaredConstructor) {
     );
   }
   const argumentTypes = declaredConstructor.argumentTypes;
-  if (!argumentTypes.every(isOpaqueCallableArgumentTypeInfo)) {
-    throw new Error(
-      `Constructor "${declaredConstructor.id}" argumentTypes are invalid.`
-    );
-  }
+  assertOpaqueCallableArgumentsValid(
+    argumentTypes,
+    `Constructor "${declaredConstructor.id}"`
+  );
   const names = /* @__PURE__ */ new Set();
   for (const argument2 of argumentTypes) {
     const name = argument2.name;
@@ -130529,9 +130583,10 @@ function assertOpaqueNSFunctionValid(member, membersById, typeInfoInDeclaringCla
   if (!Array.isArray(member.argumentTypes)) {
     throw new Error(`NSFunction "${member.id}" argumentTypes are invalid.`);
   }
-  if (!member.argumentTypes.every(isOpaqueCallableArgumentTypeInfo)) {
-    throw new Error(`NSFunction "${member.id}" has an invalid argument type.`);
-  }
+  assertOpaqueCallableArgumentsValid(
+    member.argumentTypes,
+    `NSFunction "${member.id}"`
+  );
   const argumentNames = /* @__PURE__ */ new Set();
   for (const argument2 of member.argumentTypes) {
     const name = argument2.name;
@@ -208017,7 +208072,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.82.3");
+    console.log("0.82.4");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.82.3",
+  "version": "0.82.4",
   "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.82.3 -->
+<!-- reviewed-through-cli: 0.82.4 -->
 
 # Neo Compose CLI
 

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

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

package/skills/neocompose-cli/references/declarations-and-construction.md

@@ -256,11 +256,11 @@ code types; see the NeoScript reference for handle and slot references.
 `public Reference<Config> Config` selects one row and reads as `Config`.
 `public Set<Reference<Config>> Configs` selects several and reads as
 `Set<Config>`. `public Reference<int> TrackedStat` names another member's int.
-`Reference<T>` also works as a collection element, a dictionary value, and an
-unbound generic argument such as `Box<Reference<int>>`. An initializer body for
-a single reference returns one row, never a set. `T` with
-`@settings(collection:)` is an error; the language server's quick fix respells
-it.
+`Reference<T>` also works as a constructor or method parameter, a collection
+element, a dictionary value, and an unbound generic argument such as
+`Box<Reference<int>>`. An initializer body for a single reference returns one
+row, never a set. `T` with `@settings(collection:)` is an error; the language
+server's quick fix respells it.
 
 `@settings(collection: Owner.Member)` binds a class reference to one
 collection. Without it the reference is unbound: it selects any stored row of