flingit 0.0.70 → 0.0.71

package/node_modules/flingflow/test/engine.test.ts

@@ -1,3 +1,4 @@
+import { defined } from "@glideapps/ts-necessities";
 import { describe, it, expect, beforeEach } from "vitest";
 import { Engine, UnknownWorkflowError } from "../src/engine.js";
 import { MemoryEventStore } from "../src/store-memory.js";
@@ -53,12 +54,12 @@ describe("Engine", () => {
 
       const events = (await store.getAllEvents(runId, noSim))._unsafeUnwrap();
       expect(events).toHaveLength(1);
-      expect(events[0].event_type).toBe("workflow_created");
-      expect(events[0].payload).toEqual({ workflowName: "single-step", writes: { value: "hello" }, config: { maxAttempts: 5, initialBackoffMS: 1000, backoffMultiplier: 2, maxBackoffMS: 60_000, stepTimeoutMS: 300_000 } });
-      expect(events[0].seq).toBe(0);
-      expect(events[0].created_at).toBe(1000);
-      expect(events[0].run_id).toBe("run-1");
-      expect(events[0].workflow_id).toBe("wf-single");
+      expect(defined(events[0]).event_type).toBe("workflow_created");
+      expect(defined(events[0]).payload).toEqual({ workflowName: "single-step", writes: { value: "hello" }, config: { maxAttempts: 5, initialBackoffMS: 1000, backoffMultiplier: 2, maxBackoffMS: 60_000, stepTimeoutMS: 300_000 } });
+      expect(defined(events[0]).seq).toBe(0);
+      expect(defined(events[0]).created_at).toBe(1000);
+      expect(defined(events[0]).run_id).toBe("run-1");
+      expect(defined(events[0]).workflow_id).toBe("wf-single");
     });
 
     it("rejects unknown workflow names", async () => {
@@ -109,7 +110,7 @@ describe("Engine", () => {
 
       const events = (await store.getAllEvents(runId, noSim))._unsafeUnwrap();
       const lastEvent = events[events.length - 1];
-      expect(lastEvent.event_type).toBe("workflow_failed");
+      expect(defined(lastEvent).event_type).toBe("workflow_failed");
     });
   });
 
@@ -180,8 +181,8 @@ describe("Engine", () => {
 
       // Check attempt numbers
       const starts = events.filter(e => e.event_type === "step_started");
-      expect((starts[0].payload as any).attempt).toBe(1);
-      expect((starts[1].payload as any).attempt).toBe(2);
+      expect((defined(starts[0]).payload as any).attempt).toBe(1);
+      expect((defined(starts[1]).payload as any).attempt).toBe(2);
     });
 
     it("max attempts exceeded → workflow_failed", async () => {
@@ -236,7 +237,7 @@ describe("Engine", () => {
 
       const events = (await store.getAllEvents(runId, noSim))._unsafeUnwrap();
       for (let i = 0; i < events.length; i++) {
-        expect(events[i].seq).toBe(i);
+        expect(defined(events[i]).seq).toBe(i);
       }
     });
 
@@ -267,7 +268,7 @@ describe("Engine", () => {
       (await engine.runToCompletion(runId, noSim))._unsafeUnwrap();
 
       const events = (await store.getAllEvents(runId, noSim))._unsafeUnwrap();
-      expect(events[0].created_at).toBe(5000); // workflow_created
+      expect(defined(events[0]).created_at).toBe(5000); // workflow_created
       for (const event of events.slice(1)) {
         expect(event.created_at).toBe(5100); // all others at clock=5100
       }
@@ -286,8 +287,8 @@ describe("Engine", () => {
       };
 
       for (let i = 0; i < events.length - 1; i++) {
-        const from = events[i].event_type;
-        const to = events[i + 1].event_type;
+        const from = defined(events[i]).event_type;
+        const to = defined(events[i + 1]).event_type;
         expect(
           validTransitions[from],
           `No valid transitions from ${from}`,
@@ -344,8 +345,8 @@ describe("Engine", () => {
 
       const events1 = (await store.getAllEvents(runId1, noSim))._unsafeUnwrap();
       const events2 = (await store.getAllEvents(runId2, noSim))._unsafeUnwrap();
-      expect(events1[events1.length - 1].event_type).toBe("workflow_completed");
-      expect(events2[events2.length - 1].event_type).toBe("workflow_completed");
+      expect(defined(events1[events1.length - 1]).event_type).toBe("workflow_completed");
+      expect(defined(events2[events2.length - 1]).event_type).toBe("workflow_completed");
     });
 
     it("successive runs of same workflow ID get different run IDs", async () => {

package/node_modules/flingflow/test/recovery.test.ts

@@ -1,3 +1,4 @@
+import { defined } from "@glideapps/ts-necessities";
 import { describe, it, expect, beforeEach } from "vitest";
 import { runRecovery } from "../src/recovery.js";
 import { Engine } from "../src/engine.js";
@@ -52,9 +53,9 @@ describe("recovery", () => {
     // step_failed should have been appended
     const events = (await store.getAllEvents("run-1", noSim))._unsafeUnwrap();
     expect(events).toHaveLength(3);
-    expect(events[2].event_type).toBe("step_failed");
-    expect((events[2].payload as any).reason).toBe("timeout");
-    expect((events[2].payload as any).retryable).toBe(true);
+    expect(defined(events[2]).event_type).toBe("step_failed");
+    expect((defined(events[2]).payload as any).reason).toBe("timeout");
+    expect((defined(events[2]).payload as any).retryable).toBe(true);
   });
 
   it("detects stuck workflow at workflow_created", async () => {
@@ -138,7 +139,7 @@ describe("recovery", () => {
 
     const events = (await store.getAllEvents("run-10", noSim))._unsafeUnwrap();
     const last = events[events.length - 1];
-    expect(last.event_type).toBe("workflow_completed");
+    expect(defined(last).event_type).toBe("workflow_completed");
   });
 
   it("detects step_completed without next_step as needing workflow_completed", async () => {

package/node_modules/flingflow/test/simulation.test.ts

@@ -1,3 +1,4 @@
+import { defined } from "@glideapps/ts-necessities";
 import { describe, it, expect } from "vitest";
 import {
   SimulationImpl,
@@ -71,24 +72,24 @@ function makeCheck(): EventStoreCheck {
 
     // Ascending seq with no gaps
     for (let i = 0; i < events.length; i++) {
-      if (events[i].seq !== i) {
+      if (defined(events[i]).seq !== i) {
         throw new Error(
-          `Check failed [${runId}]: expected seq ${i}, got ${events[i].seq}`,
+          `Check failed [${runId}]: expected seq ${i}, got ${defined(events[i]).seq}`,
         );
       }
     }
 
     // First event must be workflow_created
-    if (events[0].event_type !== "workflow_created") {
+    if (defined(events[0]).event_type !== "workflow_created") {
       throw new Error(
-        `Check failed [${runId}]: first event is ${events[0].event_type}, expected workflow_created`,
+        `Check failed [${runId}]: first event is ${defined(events[0]).event_type}, expected workflow_created`,
       );
     }
 
     // All transitions are valid
     for (let i = 0; i < events.length - 1; i++) {
-      const from = events[i].event_type;
-      const to = events[i + 1].event_type;
+      const from = defined(events[i]).event_type;
+      const to = defined(events[i + 1]).event_type;
       const allowed = validTransitions[from];
       if (!allowed?.includes(to)) {
         throw new Error(
@@ -114,15 +115,15 @@ function makeCheck(): EventStoreCheck {
 function validateEventTrace(events: WorkflowEvent[]): void {
   // Check ascending seq
   for (let i = 0; i < events.length; i++) {
-    if (events[i].seq !== i) {
-      throw new Error(`Expected seq ${i}, got ${events[i].seq}`);
+    if (defined(events[i]).seq !== i) {
+      throw new Error(`Expected seq ${i}, got ${defined(events[i]).seq}`);
     }
   }
 
   // Check valid transitions
   for (let i = 0; i < events.length - 1; i++) {
-    const from = events[i].event_type;
-    const to = events[i + 1].event_type;
+    const from = defined(events[i]).event_type;
+    const to = defined(events[i + 1]).event_type;
     const allowed = validTransitions[from];
     if (!allowed?.includes(to)) {
       throw new Error(
@@ -134,17 +135,17 @@ function validateEventTrace(events: WorkflowEvent[]): void {
   // Check terminal
   const last = events[events.length - 1];
   if (
-    last.event_type !== "workflow_completed" &&
-    last.event_type !== "workflow_failed"
+    defined(last).event_type !== "workflow_completed" &&
+    defined(last).event_type !== "workflow_failed"
   ) {
-    throw new Error(`Workflow not terminal: last event is ${last.event_type}`);
+    throw new Error(`Workflow not terminal: last event is ${defined(last).event_type}`);
   }
 }
 
 function simulationTests(
   name: string,
   createStore: () => Promise<EventStore>,
-) {
+): void {
   describe(`simulation tests (${name})`, () => {
     it("concurrent workers: exactly one claims each step", async () => {
       const store = await createStore();
@@ -188,8 +189,8 @@ function simulationTests(
       validateEventTrace(events);
 
       const last = events[events.length - 1];
-      expect(last.event_type).toBe("workflow_completed");
-      expect((last.payload as any).result).toEqual({ finalCount: 3 });
+      expect(defined(last).event_type).toBe("workflow_completed");
+      expect((defined(last).payload as any).result).toEqual({ finalCount: 3 });
     });
 
     it("concurrent workers across multiple seeds", async () => {
@@ -242,7 +243,7 @@ function simulationTests(
         validateEventTrace(events);
 
         const last = events[events.length - 1];
-        expect(last.event_type).toBe("workflow_completed");
+        expect(defined(last).event_type).toBe("workflow_completed");
       }
     });
 
@@ -315,12 +316,12 @@ function simulationTests(
 
       if (events.length > 0) {
         for (let i = 0; i < events.length; i++) {
-          expect(events[i].seq).toBe(i);
+          expect(defined(events[i]).seq).toBe(i);
         }
 
         for (let i = 0; i < events.length - 1; i++) {
-          const from = events[i].event_type;
-          const to = events[i + 1].event_type;
+          const from = defined(events[i]).event_type;
+          const to = defined(events[i + 1]).event_type;
           const allowed = validTransitions[from];
           expect(allowed, `No transitions defined from ${from}`).toBeDefined();
           expect(

package/node_modules/flingflow/test/store-conformance.ts

@@ -1,3 +1,4 @@
+import { defined } from "@glideapps/ts-necessities";
 import { describe, it, expect, beforeEach } from "vitest";
 import { UniqueConstraintError, WorkflowAlreadyActiveError, WorkflowIdMismatchError, type EventStore } from "../src/store.js";
 import type { WorkflowConfig, WorkflowEvent } from "../src/types.js";
@@ -5,7 +6,7 @@ import { noSim } from "./fixtures.js";
 
 const TEST_CONFIG: WorkflowConfig = { maxAttempts: 5, initialBackoffMS: 1000, backoffMultiplier: 2, maxBackoffMS: 60_000, stepTimeoutMS: 300_000 };
 
-export function storeConformanceTests(name: string, createStore: () => Promise<EventStore>) {
+export function storeConformanceTests(name: string, createStore: () => Promise<EventStore>): void {
   describe(`${name} conformance`, () => {
     let store: EventStore;
 
@@ -43,8 +44,8 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
       }, noSim))._unsafeUnwrap();
 
       const last = (await store.getLastEvent("run-1", noSim))._unsafeUnwrap();
-      expect(last!.seq).toBe(1);
-      expect(last!.event_type).toBe("step_started");
+      expect(last?.seq).toBe(1);
+      expect(last?.event_type).toBe("step_started");
     });
 
     it("returns UniqueConstraintError on duplicate (run_id, seq)", async () => {
@@ -88,7 +89,7 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
       // seq=1 should NOT be present since batch is atomic
       const all = (await store.getAllEvents("run-1", noSim))._unsafeUnwrap();
       expect(all).toHaveLength(1);
-      expect(all[0].seq).toBe(0);
+      expect(defined(all[0]).seq).toBe(0);
     });
 
     it("getEvent returns specific event", async () => {
@@ -98,9 +99,12 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
       }, noSim))._unsafeUnwrap();
 
       const event = (await store.getEvent("run-1", 0, noSim))._unsafeUnwrap();
-      expect(event).not.toBeNull();
-      expect(event!.event_type).toBe("workflow_created");
-      expect((event!.payload as any).writes).toEqual({ x: 1 });
+      // `defined()` only rules out undefined, and getEvent returns
+      // `WorkflowEvent | null` — narrow explicitly so the assertions below run
+      // against a real event rather than silently against null.
+      if (event === null) throw new Error("getEvent returned null for seq 0");
+      expect(event.event_type).toBe("workflow_created");
+      expect((event.payload as any).writes).toEqual({ x: 1 });
     });
 
     it("getEvent returns null for missing seq", async () => {
@@ -119,8 +123,8 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
 
       const completed = (await store.getCompletedEvents("run-1", noSim))._unsafeUnwrap();
       expect(completed).toHaveLength(2);
-      expect(completed[0].seq).toBe(4); // newest first
-      expect(completed[1].seq).toBe(2);
+      expect(defined(completed[0]).seq).toBe(4); // newest first
+      expect(defined(completed[1]).seq).toBe(2);
     });
 
     it("getAllEvents returns events in seq ASC order", async () => {
@@ -131,8 +135,8 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
 
       const all = (await store.getAllEvents("run-1", noSim))._unsafeUnwrap();
       expect(all).toHaveLength(2);
-      expect(all[0].seq).toBe(0);
-      expect(all[1].seq).toBe(1);
+      expect(defined(all[0]).seq).toBe(0);
+      expect(defined(all[1]).seq).toBe(1);
     });
 
     it("getActiveWorkflows excludes terminal workflows", async () => {
@@ -160,7 +164,7 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
 
       const active = (await store.getActiveWorkflows(noSim))._unsafeUnwrap();
       expect(active).toHaveLength(1);
-      expect(active[0].run_id).toBe("run-active");
+      expect(defined(active[0]).run_id).toBe("run-active");
     });
 
     it("JSON round-trips payloads correctly", async () => {
@@ -175,8 +179,8 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
       }, noSim))._unsafeUnwrap();
 
       const retrieved = (await store.getEvent("run-json", 0, noSim))._unsafeUnwrap();
-      expect(retrieved!.payload).toEqual(payload);
-      expect(retrieved!.payload).not.toBe(payload);
+      expect(retrieved?.payload).toEqual(payload);
+      expect(retrieved?.payload).not.toBe(payload);
     });
 
     it("isolates events between different runs", async () => {
@@ -193,8 +197,8 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
       const allB = (await store.getAllEvents("run-b", noSim))._unsafeUnwrap();
       expect(allA).toHaveLength(1);
       expect(allB).toHaveLength(1);
-      expect((allA[0].payload as any).workflowName).toBe("a");
-      expect((allB[0].payload as any).workflowName).toBe("b");
+      expect((defined(allA[0]).payload as any).workflowName).toBe("a");
+      expect((defined(allB[0]).payload as any).workflowName).toBe("b");
     });
 
     // --- appendIfNoActiveWorkflow tests ---
@@ -268,9 +272,9 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
 
       const runs = (await store.getRecentRuns(10, noSim))._unsafeUnwrap();
       expect(runs).toHaveLength(3);
-      expect(runs[0].run_id).toBe("run-new");
-      expect(runs[1].run_id).toBe("run-mid");
-      expect(runs[2].run_id).toBe("run-old");
+      expect(defined(runs[0]).run_id).toBe("run-new");
+      expect(defined(runs[1]).run_id).toBe("run-mid");
+      expect(defined(runs[2]).run_id).toBe("run-old");
       // All should be seq=0 (workflow_created)
       for (const run of runs) {
         expect(run.seq).toBe(0);
@@ -294,8 +298,8 @@ export function storeConformanceTests(name: string, createStore: () => Promise<E
 
       const runs = (await store.getRecentRuns(2, noSim))._unsafeUnwrap();
       expect(runs).toHaveLength(2);
-      expect(runs[0].run_id).toBe("run-3");
-      expect(runs[1].run_id).toBe("run-2");
+      expect(defined(runs[0]).run_id).toBe("run-3");
+      expect(defined(runs[1]).run_id).toBe("run-2");
     });
 
     it("getRecentRuns returns empty array when no runs exist", async () => {

package/node_modules/flingflow/tsconfig.typecheck.json

@@ -15,6 +15,6 @@
     "allowUnusedLabels": false,
     "allowUnreachableCode": false
   },
-  "include": ["src/**/*.ts"],
+  "include": ["src/**/*.ts", "test/**/*.ts"],
   "exclude": ["node_modules", "dist"]
 }

package/node_modules/semver/README.md

@@ -56,6 +56,7 @@ const semverCompareLoose = require('semver/functions/compare-loose')
 const semverCompareBuild = require('semver/functions/compare-build')
 const semverSort = require('semver/functions/sort')
 const semverRsort = require('semver/functions/rsort')
+const semverTruncate = require('semver/functions/truncate')
 
 // low-level comparators between versions
 const semverGt = require('semver/functions/gt')
@@ -110,8 +111,9 @@ Options:
 -l --loose
         Interpret versions and ranges loosely
 
--n <0|1>
-        This is the base to be used for the prerelease identifier.
+-n <0|1|false>
+        Base number for prerelease identifier (default: 0).
+        Use false to omit the number altogether.
 
 -p --include-prerelease
         Always include prerelease versions in range matching
@@ -398,12 +400,19 @@ nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
 tilde      ::= '~' partial
 caret      ::= '^' partial
 qualifier  ::= ( '-' pre )? ( '+' build )?
-pre        ::= parts
-build      ::= parts
-parts      ::= part ( '.' part ) *
-part       ::= nr | [-0-9A-Za-z]+
+pre        ::= prepart ( '.' prepart ) *
+prepart    ::= nr | alphanumid
+build      ::= buildid ( '.' buildid ) *
+alphanumid ::= ( ['0'-'9'] ) * [-A-Za-z] [-0-9A-Za-z] *
+buildid    ::= [-0-9A-Za-z]+
 ```
 
+Note: Prerelease identifiers (`pre`) use `nr` for numeric parts, which
+disallows leading zeros (e.g., `1.2.3-00` is invalid). Build metadata
+identifiers (`build`) allow any alphanumeric string including leading
+zeros (e.g., `1.2.3+00` is valid). This matches the
+[SemVer 2.0.0 specification](https://semver.org/#spec-item-9).
+
 ## Functions
 
 All methods and classes take a final `options` object argument.  All
@@ -448,6 +457,12 @@ strings that they parse.
   or comparators intersect.
 * `parse(v)`: Attempt to parse a string as a semantic version, returning either
   a `SemVer` object or `null`.
+* `truncate(v, releaseType)`: Return the version with components _lower_
+  than `releaseType` dropped off, e.g.:
+  * `major` removes build & prerelease info and sets minor & patch to 0.
+  * `minor` removes build & prerelease info, and sets patch to 0
+  * `patch` removes build & prerelease info
+  * All prerelease types remove build info only
 
 ### Comparison
 
@@ -649,6 +664,7 @@ The following modules are available:
 * `require('semver/functions/rsort')`
 * `require('semver/functions/satisfies')`
 * `require('semver/functions/sort')`
+* `require('semver/functions/truncate')`
 * `require('semver/functions/valid')`
 * `require('semver/ranges/gtr')`
 * `require('semver/ranges/intersects')`

package/node_modules/semver/bin/semver.js

@@ -46,6 +46,7 @@ const main = () => {
       a = a.slice(0, indexOfEqualSign)
       argv.unshift(value)
     }
+
     switch (a) {
       case '-rv': case '-rev': case '--rev': case '--reverse':
         reverse = true
@@ -60,15 +61,10 @@ const main = () => {
         versions.push(argv.shift())
         break
       case '-i': case '--inc': case '--increment':
-        switch (argv[0]) {
-          case 'major': case 'minor': case 'patch': case 'prerelease':
-          case 'premajor': case 'preminor': case 'prepatch':
-          case 'release':
-            inc = argv.shift()
-            break
-          default:
-            inc = 'patch'
-            break
+        if (semver.RELEASE_TYPES.includes(argv[0]) || (argv[0] === 'release')) {
+          inc = { value: argv.shift(), maybeErrantValue: null, option: a }
+        } else {
+          inc = { value: 'patch', maybeErrantValue: argv[0], option: a }
         }
         break
       case '--preid':
@@ -102,10 +98,18 @@ const main = () => {
 
   options = parseOptions({ loose, includePrerelease, rtl })
 
+  if (
+    inc &&
+    versions.includes(inc.maybeErrantValue) &&
+    !semver.valid(inc.maybeErrantValue, options)
+  ) {
+    console.warn(`Invalid value for ${inc.option}; defaulting to 'patch'. This may become a failure in future major versions.`)
+  }
+
   versions = versions.map((v) => {
     return coerce ? (semver.coerce(v, options) || { version: v }).version : v
   }).filter((v) => {
-    return semver.valid(v)
+    return semver.valid(v, options)
   })
   if (!versions.length) {
     return fail()
@@ -125,7 +129,7 @@ const main = () => {
   versions
     .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options))
     .map(v => semver.clean(v, options))
-    .map(v => inc ? semver.inc(v, inc, options, identifier, identifierBase) : v)
+    .map(v => inc ? semver.inc(v, inc.value, options, identifier, identifierBase) : v)
     .forEach(v => console.log(v))
 }
 

package/node_modules/semver/classes/range.js

@@ -98,6 +98,9 @@ class Range {
   }
 
   parseRange (range) {
+    // strip build metadata so it can't bleed into the version
+    range = range.replace(BUILDSTRIPRE, '')
+
     // memoize range parsing for performance.
     // this is a very hot path, and fully deterministic.
     const memoOpts =
@@ -223,6 +226,7 @@ const debug = require('../internal/debug')
 const SemVer = require('./semver')
 const {
   safeRe: re,
+  src,
   t,
   comparatorTrimReplace,
   tildeTrimReplace,
@@ -230,6 +234,9 @@ const {
 } = require('../internal/re')
 const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')
 
+// unbounded global build-metadata stripper used by parseRange
+const BUILDSTRIPRE = new RegExp(src[t.BUILD], 'g')
+
 const isNullSet = c => c.value === '<0.0.0-0'
 const isAny = c => c.value === ''
 
@@ -270,6 +277,11 @@ const parseComparator = (comp, options) => {
 
 const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
 
+const invalidXRangeOrder = (M, m, p) => (
+  (isX(M) && !isX(m)) ||
+  (isX(m) && p && !isX(p))
+)
+
 // ~, ~> --> * (any, kinda silly)
 // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
 // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
@@ -287,6 +299,10 @@ const replaceTildes = (comp, options) => {
 
 const replaceTilde = (comp, options) => {
   const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+  // if we're including prereleases in the match, then the lower bound is
+  // -0, the lowest possible prerelease value, just like x-ranges and carets.
+  // this keeps `~1.2` equivalent to the `1.2.x` x-range it's documented as.
+  const z = options.includePrerelease ? '-0' : ''
   return comp.replace(r, (_, M, m, p, pr) => {
     debug('tilde', comp, _, M, m, p, pr)
     let ret
@@ -294,10 +310,10 @@ const replaceTilde = (comp, options) => {
     if (isX(M)) {
       ret = ''
     } else if (isX(m)) {
-      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
     } else if (isX(p)) {
       // ~1.2 == >=1.2.0 <1.3.0-0
-      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+      ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
     } else if (pr) {
       debug('replaceTilde pr', pr)
       ret = `>=${M}.${m}.${p}-${pr
@@ -366,10 +382,10 @@ const replaceCaret = (comp, options) => {
       if (M === '0') {
         if (m === '0') {
           ret = `>=${M}.${m}.${p
-          }${z} <${M}.${m}.${+p + 1}-0`
+          } <${M}.${m}.${+p + 1}-0`
         } else {
           ret = `>=${M}.${m}.${p
-          }${z} <${M}.${+m + 1}.0-0`
+          } <${M}.${+m + 1}.0-0`
         }
       } else {
         ret = `>=${M}.${m}.${p
@@ -395,6 +411,10 @@ const replaceXRange = (comp, options) => {
   const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
   return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
     debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    if (invalidXRangeOrder(M, m, p)) {
+      return comp
+    }
+
     const xM = isX(M)
     const xm = xM || isX(m)
     const xp = xm || isX(p)

package/node_modules/semver/classes/semver.js

@@ -6,6 +6,22 @@ const { safeRe: re, t } = require('../internal/re')
 
 const parseOptions = require('../internal/parse-options')
 const { compareIdentifiers } = require('../internal/identifiers')
+
+const isPrereleaseIdentifier = (prerelease, identifier) => {
+  const identifiers = identifier.split('.')
+  if (identifiers.length > prerelease.length) {
+    return false
+  }
+
+  for (let i = 0; i < identifiers.length; i++) {
+    if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+      return false
+    }
+  }
+
+  return true
+}
+
 class SemVer {
   constructor (version, options) {
     options = parseOptions(options)
@@ -309,8 +325,9 @@ class SemVer {
           if (identifierBase === false) {
             prerelease = [identifier]
           }
-          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-            if (isNaN(this.prerelease[1])) {
+          if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+            const prereleaseBase = this.prerelease[identifier.split('.').length]
+            if (isNaN(prereleaseBase)) {
               this.prerelease = prerelease
             }
           } else {

package/node_modules/semver/functions/diff.js

@@ -53,7 +53,7 @@ const diff = (version1, version2) => {
     return prefix + 'patch'
   }
 
-  // high and low are preleases
+  // high and low are prereleases
   return 'prerelease'
 }
 

package/node_modules/semver/functions/truncate.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const parse = require('./parse')
+const constants = require('../internal/constants')
+const SemVer = require('../classes/semver')
+
+const truncate = (version, truncation, options) => {
+  if (!constants.RELEASE_TYPES.includes(truncation)) {
+    return null
+  }
+
+  const clonedVersion = cloneInputVersion(version, options)
+  return clonedVersion && doTruncation(clonedVersion, truncation)
+}
+
+const cloneInputVersion = (version, options) => {
+  const versionStringToParse = (
+    version instanceof SemVer ? version.version : version
+  )
+
+  return parse(versionStringToParse, options)
+}
+
+const doTruncation = (version, truncation) => {
+  if (isPrerelease(truncation)) {
+    return version.version
+  }
+
+  version.prerelease = []
+
+  switch (truncation) {
+    case 'major':
+      version.minor = 0
+      version.patch = 0
+      break
+    case 'minor':
+      version.patch = 0
+      break
+  }
+
+  return version.format()
+}
+
+const isPrerelease = (type) => {
+  return type.startsWith('pre')
+}
+
+module.exports = truncate