@neocompose/cli 0.66.0 → 0.67.1

package/dist/test-worker.mjs

@@ -1755,7 +1755,7 @@ var TEST_GLOBALS = [
 ];
 
 // ../packages/neoscript-language/src/strict-ir.ts
-var NEOSCRIPT_COMPILER_REVISION = 16;
+var NEOSCRIPT_COMPILER_REVISION = 17;
 
 // ../src/models/members/member-storage.ts
 function isMemberStorageKind(value) {
@@ -2167,6 +2167,11 @@ function isValidDocsText(value) {
   return textEncoder.encode(value).byteLength <= DOCS_TEXT_MAX_UTF8_BYTES;
 }
 
+// ../src/models/members/float32.ts
+function isFloat32(value) {
+  return typeof value === "number" && Number.isFinite(value) && Math.fround(value) === value;
+}
+
 // ../packages/neoscript-language/src/project-source-identifiers.ts
 var PROJECT_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var PROJECT_RESERVED_NAMES = /* @__PURE__ */ new Set([
@@ -2507,7 +2512,7 @@ function hasValidParameterDefault(value) {
     case 2 /* Int */:
       return typeof payload === "number" && Number.isInteger(payload);
     case 4 /* Float */:
-      return typeof payload === "number" && Number.isFinite(payload);
+      return isFloat32(payload);
     case 20 /* Decimal */:
     case 3 /* String */:
     case 8 /* Enum */:
@@ -2793,6 +2798,9 @@ function isNSArithmeticOperationInfo(value) {
   const v = value;
   if (typeof v !== "object" || v === null) return false;
   if (!isNSArithmeticOperationType(v.type)) return false;
+  if (v.numeric !== void 0 && v.numeric !== "int" && v.numeric !== "float") {
+    return false;
+  }
   return isNSPointers(v.pointers);
 }
 function isNSArithmeticOperation(value) {
@@ -3703,6 +3711,9 @@ var STRUCTURED_LEAF_FIELDS = {
 function isStructuredLeafKind(kind) {
   return Object.prototype.hasOwnProperty.call(STRUCTURED_LEAF_FIELDS, kind);
 }
+function structuredLeafFields(kind) {
+  return STRUCTURED_LEAF_FIELDS[kind];
+}
 function structuredLeafFieldKeys(kind) {
   return STRUCTURED_LEAF_FIELDS[kind].map((entry) => entry.key);
 }
@@ -3715,10 +3726,10 @@ function isStructuredLeafFieldValue(type, value) {
     return typeof value === "string" && value.length > 0;
   }
   if (typeof value !== "number" || !Number.isFinite(value)) return false;
-  if (type === "float") return true;
+  if (type === "float") return isFloat32(value);
   if (type === "int") return Number.isInteger(value);
   if (type === "sliceIndex") return Number.isInteger(value) && value >= 0;
-  return value >= 0 && value <= 1;
+  return isFloat32(value) && value >= 0 && value <= 1;
 }
 var STRUCTURED_LEAF_PARTIAL_KEY = "~partial";
 function isStructuredLeafPartialValue(value) {
@@ -3738,16 +3749,36 @@ function structuredLeafPartialViolation(kind, value, legalKeysLabel) {
       return `has no field "${key}"; ${legalKeysLabel} accepts ${structuredLeafFieldKeys(kind).join(", ")}`;
     }
     if (isStructuredLeafFieldValue(field.type, fieldValue)) continue;
-    return `field "${key}" ${structuredLeafFieldViolation(field.type)}`;
+    return `field "${key}" ${structuredLeafFieldViolation(field.type, fieldValue)}`;
   }
   return null;
 }
-function structuredLeafFieldViolation(type) {
+function structuredLeafRecordFieldViolation(kind, value) {
+  if (typeof value !== "object" || value === null) return null;
+  if (Array.isArray(value)) return null;
+  const entries = Object.entries(value);
+  if (entries.length !== structuredLeafFields(kind).length) return null;
+  let found = null;
+  for (const [key, fieldValue] of entries) {
+    const field = structuredLeafField(kind, key);
+    if (field === null) return null;
+    if (typeof fieldValue !== "number") return null;
+    if (found !== null) continue;
+    if (isStructuredLeafFieldValue(field.type, fieldValue)) continue;
+    found = {
+      key,
+      value: fieldValue,
+      violation: structuredLeafFieldViolation(field.type, fieldValue)
+    };
+  }
+  return found;
+}
+function structuredLeafFieldViolation(type, value) {
   if (type === "fileId") return "must be a non-empty file id";
-  if (type === "float") return "must be a finite number";
   if (type === "int") return "must be a whole number";
   if (type === "sliceIndex") return "must be a whole number 0 or greater";
-  return "must be a number between 0 and 1";
+  if (!isFloat32(value)) return "must be a 32-bit float";
+  return "must be between 0 and 1";
 }
 
 // ../src/models/members/member-kinds.ts
@@ -3894,9 +3925,9 @@ function isMemberString(value) {
 function isMemberFloatBase(value) {
   const v = asMemberBaseForKind(value, 4 /* Float */);
   if (v === null) return false;
-  if (v.minValue !== void 0 && v.minValue !== null && typeof v.minValue !== "number")
+  if (v.minValue !== void 0 && v.minValue !== null && !isFloat32(v.minValue))
     return false;
-  if (v.maxValue !== void 0 && v.maxValue !== null && typeof v.maxValue !== "number")
+  if (v.maxValue !== void 0 && v.maxValue !== null && !isFloat32(v.maxValue))
     return false;
   return v.decimalPoints === void 0 || v.decimalPoints === null || typeof v.decimalPoints === "number";
 }
@@ -3905,12 +3936,8 @@ function hasExactKeys(value, keys) {
   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, integer2) {
-  if (!isFiniteNumberValue(value)) return false;
-  if (!integer2) return true;
+  if (!integer2) return isFloat32(value);
   return Number.isInteger(value);
 }
 function isVector2ValueWithComponents(value, integer2) {
@@ -3944,7 +3971,7 @@ function isVector3IntValue(value) {
   return isVector3ValueWithComponents(value, true);
 }
 function isColorComponentValue(value) {
-  if (!isFiniteNumberValue(value)) return false;
+  if (!isFloat32(value)) return false;
   return value >= 0 && value <= 1;
 }
 function isColorValue(value) {
@@ -10038,6 +10065,9 @@ function structuredLeafPartialMemberViolation(member, value, position) {
   }
   return structuredLeafPartialViolation(kind, value, MemberKind[kind]);
 }
+function storedLeafFieldIssueMessage(issue) {
+  return `${MemberKind[issue.leaf]} field "${issue.key}" ${issue.violation}, not ${issue.value}.`;
+}
 function* storedValueChildEntries(args) {
   const entryMemberId = args.member.entryMemberId;
   if (args.member.kind === 6 /* List */ && typeof entryMemberId === "string") {
@@ -10071,16 +10101,19 @@ function* storedValueChildEntries(args) {
 }
 function storedLeafShapeIssue(member, value) {
   switch (member.kind) {
+    // Null is an optional Float's absent value.
+    case 4 /* Float */:
+      return value === null || isFloat32(value) ? null : { kind: "float" };
     case 14 /* Vector2 */:
-      return isVector2Value(value) ? null : { kind: "vector2" };
+      return isVector2Value(value) ? null : leafIssue(member.kind, "vector2", value);
     case 15 /* Vector2Int */:
-      return isVector2IntValue(value) ? null : { kind: "vector2Int" };
+      return isVector2IntValue(value) ? null : leafIssue(member.kind, "vector2Int", value);
     case 16 /* Vector3 */:
-      return isVector3Value(value) ? null : { kind: "vector3" };
+      return isVector3Value(value) ? null : leafIssue(member.kind, "vector3", value);
     case 17 /* Vector3Int */:
-      return isVector3IntValue(value) ? null : { kind: "vector3Int" };
+      return isVector3IntValue(value) ? null : leafIssue(member.kind, "vector3Int", value);
     case 19 /* Color */:
-      return isColorValue(value) ? null : { kind: "color" };
+      return isColorValue(value) ? null : leafIssue(member.kind, "color", value);
     case 20 /* Decimal */: {
       const violation = getDecimalStringViolation(value);
       return violation === null ? null : { kind: "decimal", violation };
@@ -10093,6 +10126,10 @@ function storedLeafShapeIssue(member, value) {
       return null;
   }
 }
+function leafIssue(leaf, shape, value) {
+  const field = structuredLeafRecordFieldViolation(leaf, value);
+  return field === null ? { kind: shape } : { kind: "field", leaf, ...field };
+}
 
 // ../src/models/members/build-default-member-value.ts
 var DECLARATION_DEFAULT_POSITION = {
@@ -11174,16 +11211,24 @@ function validateProjectDocumentFileMemberValue(document2, member, body, positio
     return;
   }
   const shapeIssue = storedLeafShapeIssue(member, body.value);
+  if (shapeIssue?.kind === "float") {
+    throw new Error(
+      `Float value for member "${member.name}" must be a 32-bit float, not ${String(body.value)}.`
+    );
+  }
+  if (shapeIssue?.kind === "field") {
+    throw new Error(
+      `Member "${member.name}" ${storedLeafFieldIssueMessage(shapeIssue)}`
+    );
+  }
   if (shapeIssue?.kind === "vector2") {
-    throw new Error("Vector2 value must be { x: number, y: number }.");
+    throw new Error("Vector2 value must be { x: float, y: float }.");
   }
   if (shapeIssue?.kind === "vector2Int") {
     throw new Error("Vector2Int value must be { x: integer, y: integer }.");
   }
   if (shapeIssue?.kind === "vector3") {
-    throw new Error(
-      "Vector3 value must be { x: number, y: number, z: number }."
-    );
+    throw new Error("Vector3 value must be { x: float, y: float, z: float }.");
   }
   if (shapeIssue?.kind === "vector3Int") {
     throw new Error(
@@ -11192,7 +11237,7 @@ function validateProjectDocumentFileMemberValue(document2, member, body, positio
   }
   if (shapeIssue?.kind === "color") {
     throw new Error(
-      "Color value must be { r, g, b, a } with each component in [0, 1]."
+      "Color value must be { r, g, b, a } with each component a 32-bit float in [0, 1]."
     );
   }
   if (shapeIssue?.kind === "decimal") {
@@ -17454,7 +17499,8 @@ function evalPointer(pointer, scope, ctx, resultUsage = "value") {
         callSiteId: pointer.callSiteId,
         invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(delegate, delegateArgs, ctx, pointer.callSiteId)
       });
-      if (intercepted?.handled === true) return intercepted.value;
+      if (intercepted?.handled === true)
+        return hostCallResult(member, intercepted.value, ctx);
       if (member === null) {
         if (pointer.missingMemberFallback === "valueEquality") {
           return jsEqual(innerThis, suppliedArgs[0]);
@@ -17490,7 +17536,8 @@ function evalPointer(pointer, scope, ctx, resultUsage = "value") {
             pointer.callSiteId
           )
         });
-        if (hosted?.handled === true) return hosted.value;
+        if (hosted?.handled === true)
+          return hostCallResult(member, hosted.value, ctx);
         const receiverId = trackedRowForValueReference(innerThis, ctx)?.id;
         throw new NativeFunctionDelegateUnavailableError(
           `No native delegate handled Function '${member.name}' (member id '${member.id}'${nativeReceiverDescription(member, innerThis, receiverId)}). Web preview and other non-native evaluator hosts must configure a native handler or call interceptor before evaluation.`,
@@ -17781,7 +17828,8 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
     callSiteId,
     invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(delegate, delegateArgs, ctx, callSiteId)
   });
-  if (intercepted?.handled === true) return intercepted.value;
+  if (intercepted?.handled === true)
+    return hostCallResult(member, intercepted.value, ctx);
   state.delegateStack.push(frame);
   try {
     if (member.kind === 13 /* Function */) {
@@ -17796,7 +17844,8 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
         callSiteId,
         invokeDelegate: (delegate, delegateArgs = []) => invokeDelegateValue(delegate, delegateArgs, ctx, callSiteId)
       });
-      if (hosted?.handled === true) return hosted.value;
+      if (hosted?.handled === true)
+        return hostCallResult(member, hosted.value, ctx);
       const receiverId = trackedRowForValueReference(receiver, ctx)?.id;
       throw new NativeFunctionDelegateUnavailableError(
         `No native delegate handled Function '${member.name}' (member id '${member.id}'${nativeReceiverDescription(member, receiver, receiverId)}). Web preview and other non-native evaluator hosts must configure a native handler or call interceptor before evaluation.`,
@@ -18665,13 +18714,14 @@ function runtimeCollectionEntryMatchesType(value, typeInfo, ctx, seenCollections
   return resolved !== value && runtimeValueMatchesType(resolved, typeInfo, ctx, seenCollections);
 }
 function evalVectorConstructor(vectorType, componentPointers, scope, ctx) {
-  const values = componentPointers.map(
-    (pointer) => finiteNumberArg(
+  const integer2 = vectorType === 15 /* Vector2Int */ || vectorType === 17 /* Vector3Int */;
+  const values = componentPointers.map((pointer) => {
+    const value = finiteNumberArg(
       evalPointer(pointer, scope, ctx),
       `${MemberKind[vectorType]} component`
-    )
-  );
-  const integer2 = vectorType === 15 /* Vector2Int */ || vectorType === 17 /* Vector3Int */;
+    );
+    return integer2 ? value : Math.fround(value);
+  });
   if (integer2 && values.some((value) => !Number.isInteger(value))) {
     throw new NSGetterRuntimeError(
       `${MemberKind[vectorType]} components must be integers`
@@ -19562,11 +19612,17 @@ function evalOperation(operation, scope, ctx) {
   if (operation.type === "arithmetic" /* arithmetic */) {
     const op = operation.arithmetic;
     const operands = op.pointers.map((p) => evalPointer(p, scope, ctx));
-    return applyArithmetic(op.type, operands, op.decimal === true, ctx);
+    return applyArithmetic(
+      op.type,
+      operands,
+      op.decimal === true,
+      ctx,
+      op.numeric
+    );
   }
   return evalBooleanExpression(operation.expression, scope, ctx);
 }
-function applyArithmetic(op, operands, decimal, ctx) {
+function applyArithmetic(op, operands, decimal, ctx, numeric) {
   if (operands.length === 0) {
     throw new NSGetterRuntimeError("Arithmetic operation with no operands");
   }
@@ -19599,31 +19655,43 @@ function applyArithmetic(op, operands, decimal, ctx) {
       `Arithmetic operand is not numeric: ${typeof o}`
     );
   });
+  const round = numeric === "float" ? Math.fround : (value) => value;
   switch (op) {
     case "+" /* addition */:
-      return numbers.reduce((a, b) => a + b, 0);
+      return numbers.reduce((a, b) => round(a + b), 0);
     case "-" /* subtraction */:
-      return numbers.reduce((a, b, i) => i === 0 ? b : a - b);
+      return numbers.reduce((a, b, i) => i === 0 ? b : round(a - b));
     case "*" /* multiplication */:
-      return numbers.reduce((a, b) => a * b, 1);
+      return numbers.reduce((a, b) => round(a * b), 1);
     case "/" /* division */:
       return numbers.reduce((a, b, i) => {
         if (i === 0) return b;
         if (b === 0) throw new NSGetterRuntimeError("Division by zero");
-        return a / b;
+        return numeric === "int" ? Math.trunc(a / b) : round(a / b);
       });
     case "%" /* remainder */:
       return numbers.reduce((a, b, i) => {
         if (i === 0) return b;
         if (b === 0) throw new NSGetterRuntimeError("Modulo by zero");
-        return a % b;
+        return round(a % b);
       });
   }
 }
+function hostCallResult(member, value, ctx) {
+  if (typeof value !== "number" || member === null) return value;
+  if (member.kind !== 13 /* Function */ && member.kind !== 23 /* NSFunction */) {
+    return value;
+  }
+  const signature = resolveCallableSignature(member.id, member.kind, ctx);
+  return signature?.returnTypeInfo.type === 4 /* Float */ ? Math.fround(value) : value;
+}
 function coerceAssignmentValue(value, targetTypeInfo, context) {
   if (targetTypeInfo.type === 8 /* Enum */ && typeof value === "string") {
     return [value];
   }
+  if (targetTypeInfo.type === 4 /* Float */ && typeof value === "number") {
+    return Math.fround(value);
+  }
   return targetTypeInfo.type === 20 /* Decimal */ && typeof value === "number" ? coerceDecimalOperand(value, context) : value;
 }
 function coerceDecimalOperand(value, context) {
@@ -19786,7 +19854,7 @@ function evalMathOp(info, scope, ctx) {
       if (value < 0) return -1;
       return 0;
     case "sqrt":
-      return Math.sqrt(value);
+      return Math.fround(Math.sqrt(value));
   }
 }
 function evalDecimalMathOp(info, fn, scope, ctx) {
@@ -20427,8 +20495,10 @@ function evalFunction(fn, scope, ctx) {
             );
           }
           case "toFloat":
-            return floatFromDecimalString(
-              coerceDecimalOperand(receiverRaw, "ToFloat")
+            return Math.fround(
+              floatFromDecimalString(
+                coerceDecimalOperand(receiverRaw, "ToFloat")
+              )
             );
           case "toDecimal": {
             if (typeof receiverRaw !== "number") {
@@ -20937,6 +21007,9 @@ function evaluateConstructorFields(descriptor, scope, ctx) {
         `constructor field '${validated.schemaKey}'`
       );
     }
+    if (typeof value === "number" && validated.typeInfo.type === 4 /* Float */) {
+      value = Math.fround(value);
+    }
     if (value === null || value === void 0) {
       if (validated.requiredWithoutDefault) {
         throw new NSGetterRuntimeError(
@@ -21557,8 +21630,9 @@ function evaluateDeclaredConstructorArguments(info, record2, scope, ctx) {
       );
     }
     const value = byName.get(parameter3.name);
-    if (parameter3.type !== 20 /* Decimal */) return value;
     if (typeof value !== "number") return value;
+    if (parameter3.type === 4 /* Float */) return Math.fround(value);
+    if (parameter3.type !== 20 /* Decimal */) return value;
     return coerceDecimalOperand(
       value,
       `constructor argument '${parameter3.name}'`
@@ -32599,7 +32673,10 @@ var StrictNeoScriptResolver = class {
             canonicalDecimal(expression.raw, expression.pos)
           );
         }
-        return literal({ kind: "primitive", name: "float" }, expression.value);
+        return literal(
+          { kind: "primitive", name: "float" },
+          Math.fround(expression.value)
+        );
       }
       case "litString":
         return literal({ kind: "primitive", name: "string" }, expression.value);
@@ -37233,7 +37310,9 @@ var StrictNeoScriptResolver = class {
           arithmetic: {
             type: operator,
             pointers: [left.pointer, right.pointer],
-            ...isPrimitive(result, "decimal") ? { decimal: true } : {}
+            ...isPrimitive(result, "decimal") ? { decimal: true } : {},
+            ...isPrimitive(result, "int") ? { numeric: "int" } : {},
+            ...isPrimitive(result, "float") ? { numeric: "float" } : {}
           }
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.66.0",
+  "version": "0.67.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.66.0 -->
+<!-- reviewed-through-cli: 0.67.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.66.0 -->
+<!-- reviewed-through-cli: 0.67.1 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -40,12 +40,14 @@ without compiling it; use `neo status` to inspect local edits and diagnostics.
 An undo/reset metadata change invalidates the cursor and causes a safe
 full-snapshot fallback.
 
-After a compiler upgrade, run `neo pull` with `.neo/state.json` intact. When
-remote changes affect only compiler-owned bodies or timestamps, pull refreshes
-the cached records before local compilation and leaves authored files and
-managed binaries untouched. It handles both changed-record pulls and full
-snapshot refreshes. Added or deleted records, authored changes, and unresolved
-conflicts still require the normal merge path.
+After a compiler upgrade, run `neo pull` with `.neo/state.json` intact. Pull
+refreshes every cached record whose remote change touches only compiler-owned
+bodies or timestamps before local compilation, even when the same pull merges
+other changes. When nothing else changed, it leaves authored files and managed
+binaries untouched. Added or deleted records, authored changes, and unresolved
+conflicts take the normal merge path. Status, push, and pull refuse a baseline
+holding a compiled body this CLI rejects and name the record. If `neo pull`
+cannot refresh it, back up local edits and run `neo pull --force`.
 
 If a push commits but source rewriting fails, `neo pull` resumes its saved
 result before checking the remote head. The recovery journal in `.neo/state.json`

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

@@ -202,6 +202,14 @@ Save, Session, Setter, or otherwise writable. A constructor writes only its
 `this` instance. A writable structured-leaf field still inherits the receiver's
 effective storage restrictions.
 
+## Numeric types
+
+`int` is a 32-bit integer and `float` is a 32-bit float, matching C#. Float
+literals, stored values, and every arithmetic step round to 32 bits, so
+`0.1f + 0.2f` behaves like Unity. `int` division truncates toward zero.
+`decimal` is exact base-10 and is the only type to use for currency or other
+values that must not drift.
+
 ## Numeric builtins
 
 Use the `Math` namespace for numeric utilities with C# names and C# semantics: