@styx-api/core 0.7.0 → 0.8.0

package/src/frontend/boutiques/parser.ts

@@ -372,12 +372,21 @@ export class BoutiquesParser implements Frontend {
       case InputTypePrimitive.Integer: {
         const node: Int = { kind: "int", attrs: {} };
         if (isNumber(btInput.minimum)) {
-          node.attrs.minValue = Math.floor(btInput.minimum);
-          if (btInput["exclusive-minimum"] === true) node.attrs.minValue += 1;
+          // Smallest valid integer: for a fractional bound, `>= 5.7` allows 6
+          // (ceil) and `> 5.7` allows 6 (floor + 1); both differ from a plain
+          // floor.
+          node.attrs.minValue =
+            btInput["exclusive-minimum"] === true
+              ? Math.floor(btInput.minimum) + 1
+              : Math.ceil(btInput.minimum);
         }
         if (isNumber(btInput.maximum)) {
-          node.attrs.maxValue = Math.floor(btInput.maximum);
-          if (btInput["exclusive-maximum"] === true) node.attrs.maxValue -= 1;
+          // Largest valid integer: `<= 5.7` allows 5 (floor) and `< 5.7` allows
+          // 5 (ceil - 1).
+          node.attrs.maxValue =
+            btInput["exclusive-maximum"] === true
+              ? Math.ceil(btInput.maximum) - 1
+              : Math.floor(btInput.maximum);
         }
         if (meta) node.meta = meta;
         return node;
@@ -424,7 +433,10 @@ export class BoutiquesParser implements Frontend {
           return null;
         }
         const node = this.parseDescriptor(nested);
-        if (node && meta) node.meta = meta;
+        // Merge (not overwrite) so the subcommand's own meta - notably its
+        // `output-files`, attached by `parseDescriptor` - survives; the input's
+        // meta (name/doc) layers on top.
+        if (node && meta) node.meta = { ...node.meta, ...meta };
         return node;
       }
 
@@ -553,12 +565,19 @@ export class BoutiquesParser implements Frontend {
     }
 
     // Hoist metadata (doc, default) to outermost wrapper so backends find it
-    // on the binding node. Keep name on inner for solver's findDeepName.
+    // on the binding node. Keep `name` on inner for the solver's findDeepName,
+    // and keep `outputs` there too: outputs are a scope concept declared on the
+    // subcommand struct, not a property of the list/flag wrapper - hoisting them
+    // onto a repeat would move the output scope off the struct and make backends
+    // (which resolve outputs against the struct) silently drop them.
     if (node !== inner && inner.meta) {
-      const { name, ...rest } = inner.meta;
+      const { name, outputs, ...rest } = inner.meta;
       if (Object.keys(rest).length > 0) {
         node.meta = { ...node.meta, ...rest };
-        inner.meta = name ? { name } : undefined;
+        const kept: NodeMeta = {};
+        if (name) kept.name = name;
+        if (outputs) kept.outputs = outputs;
+        inner.meta = Object.keys(kept).length > 0 ? kept : undefined;
       }
     }
 

package/src/ir/passes/canonicalize.ts

@@ -38,6 +38,19 @@ export const canonicalize: Pass = {
       }
     }
 
+    // Identity for dedup: structure plus the meta that makes two structurally
+    // identical union arms semantically distinct - the variant tag (@type
+    // discriminant), name, and attached outputs. Deduping on structure alone
+    // would silently drop a distinct arm (e.g. two sub-commands with the same
+    // inner shape but different @type), making its variant unreachable.
+    function identityKey(node: Expr): string {
+      const m = node.meta;
+      const metaKey = m
+        ? [m.name ?? "", m.variantTag ?? "", m.outputs ? JSON.stringify(m.outputs) : ""].join("|")
+        : "";
+      return `${structuralHash(node)}#${metaKey}`;
+    }
+
     function sortKey(node: Expr): string {
       const name = node.meta?.name ?? "";
       return `${node.kind}:${name}:${structuralHash(node)}`;
@@ -51,13 +64,13 @@ export const canonicalize: Pass = {
           // Sort alternatives
           const sorted = [...children].sort((a, b) => sortKey(a).localeCompare(sortKey(b)));
 
-          // Deduplicate by structural hash
+          // Deduplicate identical arms (structure + discriminating meta).
           const seen = new Set<string>();
           const alts: Expr[] = [];
           for (const child of sorted) {
-            const hash = structuralHash(child);
-            if (!seen.has(hash)) {
-              seen.add(hash);
+            const key = identityKey(child);
+            if (!seen.has(key)) {
+              seen.add(key);
               alts.push(child);
             } else {
               changed = true;
@@ -67,7 +80,7 @@ export const canonicalize: Pass = {
           // Check if order changed
           if (
             alts.length !== children.length ||
-            alts.some((alt, i) => structuralHash(alt) !== structuralHash(children[i]!))
+            alts.some((alt, i) => identityKey(alt) !== identityKey(children[i]!))
           ) {
             changed = true;
           }

package/src/ir/passes/simplify.ts

@@ -127,15 +127,30 @@ export const simplify: Pass = {
               node.attrs.join === ""
             ) {
               changed = true;
-              prev.attrs.str += child.attrs.str;
+              // Replace with a fresh node - `prev` is the original literal object
+              // (the `literal` case returns `node` unchanged), so mutating it in
+              // place would corrupt the caller's IR and double-append on rerun.
+              nodes[nodes.length - 1] = {
+                ...prev,
+                attrs: { ...prev.attrs, str: prev.attrs.str + child.attrs.str },
+              };
             } else {
               nodes.push(child);
             }
           }
 
-          // seq(T) -> T, carrying the seq's meta down onto the child.
+          // seq(T) -> T, carrying the seq's meta down onto the child. Skip the
+          // collapse when the sequence declares outputs and the sole child is a
+          // literal: outputs need a scope binding, which the solver only forces
+          // on sequences (not on literals, which are never bound). Collapsing a
+          // parameterless output-bearing command (e.g. `seq(lit("run"))` with an
+          // output-file) onto its literal would orphan the output. A field child
+          // (str/path) does get bound, so those still collapse.
           if (nodes.length === 1) {
             const child = nodes[0]!;
+            if (node.meta?.outputs?.length && child.kind === "literal") {
+              return { ...node, attrs: { ...node.attrs, nodes } };
+            }
             changed = true;
             const mergedMeta = mergeMeta(node.meta, child.meta);
             return mergedMeta ? { ...child, meta: mergedMeta } : child;

package/src/solver/solver.ts

@@ -45,11 +45,11 @@ function isBooleanLiteralPair(variants: Array<{ type: BoundType }>): boolean {
     return false;
   }
   const [a, b] = variants.map((v) => (v.type.kind === "literal" ? v.type.value : null));
+  // `literalFromNode` canonicalizes clean-int literals, so "0"/"1" arrive as the
+  // numbers 0/1 (never strings); only "false"/"true" survive as strings.
   return (
     (a === 0 && b === 1) ||
     (a === 1 && b === 0) ||
-    (a === "0" && b === "1") ||
-    (a === "1" && b === "0") ||
     (a === "false" && b === "true") ||
     (a === "true" && b === "false")
   );