npm - flowdular - Versions diffs - 0.1.0 - Mend

flowdular 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/distribution.js ADDED Viewed

@@ -0,0 +1,4601 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/constants.js"(exports, module) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js"(exports, module) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module.exports = debug;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/re.js"(exports, module) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants();
+    var debug = require_debug();
+    exports = module.exports = {};
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var safeSrc = exports.safeSrc = [];
+    var t = exports.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      }
+      return value;
+    };
+    var createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/parse-options.js"(exports, module) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module.exports = parseOptions;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js"(exports, module) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/semver.js"(exports, module) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var SemVer = class _SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier2, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier2 && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier2) {
+            const match = `-${identifier2}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier2) {
+              throw new Error(`invalid identifier: ${identifier2}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier2, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier2, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier2, identifierBase);
+            this.inc("pre", identifier2, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier2, identifierBase);
+            }
+            this.inc("pre", identifier2, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier2 === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier2) {
+              let prerelease = [identifier2, base];
+              if (identifierBase === false) {
+                prerelease = [identifier2];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier2) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module.exports = SemVer;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module.exports = parse;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/valid.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var valid2 = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module.exports = valid2;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/clean.js
+var require_clean = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/clean.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var clean = (version, options) => {
+      const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    };
+    module.exports = clean;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/inc.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var inc = (version, release, options, identifier2, identifierBase) => {
+      if (typeof options === "string") {
+        identifierBase = identifier2;
+        identifier2 = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(
+          version instanceof SemVer ? version.version : version,
+          options
+        ).inc(release, identifier2, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    };
+    module.exports = inc;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/diff.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var diff = (version1, version2) => {
+      const v1 = parse(version1, null, true);
+      const v2 = parse(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (comparison === 0) {
+        return null;
+      }
+      const v1Higher = comparison > 0;
+      const highVersion = v1Higher ? v1 : v2;
+      const lowVersion = v1Higher ? v2 : v1;
+      const highHasPre = !!highVersion.prerelease.length;
+      const lowHasPre = !!lowVersion.prerelease.length;
+      if (lowHasPre && !highHasPre) {
+        if (!lowVersion.patch && !lowVersion.minor) {
+          return "major";
+        }
+        if (lowVersion.compareMain(highVersion) === 0) {
+          if (lowVersion.minor && !lowVersion.patch) {
+            return "minor";
+          }
+          return "patch";
+        }
+      }
+      const prefix = highHasPre ? "pre" : "";
+      if (v1.major !== v2.major) {
+        return prefix + "major";
+      }
+      if (v1.minor !== v2.minor) {
+        return prefix + "minor";
+      }
+      if (v1.patch !== v2.patch) {
+        return prefix + "patch";
+      }
+      return "prerelease";
+    };
+    module.exports = diff;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/major.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var major = (a, loose) => new SemVer(a, loose).major;
+    module.exports = major;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/minor.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var minor = (a, loose) => new SemVer(a, loose).minor;
+    module.exports = minor;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/patch.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var patch = (a, loose) => new SemVer(a, loose).patch;
+    module.exports = patch;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/prerelease.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var prerelease = (version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module.exports = prerelease;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module.exports = compare;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rcompare.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare2 = (a, b, loose) => compare(b, a, loose);
+    module.exports = rcompare2;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-loose.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var compareLoose = (a, b) => compare(a, b, true);
+    module.exports = compareLoose;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/compare-build.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compareBuild = (a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    };
+    module.exports = compareBuild;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/sort.js"(exports, module) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+    module.exports = sort;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/rsort.js"(exports, module) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+    module.exports = rsort;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gt.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module.exports = gt;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lt.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module.exports = lt;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/eq.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module.exports = eq;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/neq.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module.exports = neq;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gte.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module.exports = gte;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lte.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module.exports = lte;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/cmp.js"(exports, module) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module.exports = cmp;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = require_parse();
+    var { safeRe: re, t } = require_re();
+    var coerce = (version, options) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      if (typeof version === "number") {
+        version = String(version);
+      }
+      if (typeof version !== "string") {
+        return null;
+      }
+      options = options || {};
+      let match = null;
+      if (!options.rtl) {
+        match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
+          }
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      const major = match[2];
+      const minor = match[3] || "0";
+      const patch = match[4] || "0";
+      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    };
+    module.exports = coerce;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/lrucache.js"(exports, module) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module.exports = LRUCache;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/range.js"(exports, module) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) {
+          return cached;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version) {
+          return false;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      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);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
+          return false;
+        }
+      }
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/classes/comparator.js"(exports, module) {
+    "use strict";
+    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) {
+          return true;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/satisfies.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var satisfies2 = (version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    };
+    module.exports = satisfies2;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    module.exports = toComparators;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var maxSatisfying = (versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    };
+    module.exports = maxSatisfying;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var minSatisfying = (versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    };
+    module.exports = minSatisfying;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/min-version.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var gt = require_gt();
+    var minVersion = (range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            /* fallthrough */
+            case "":
+            case ">=":
+              if (!setMin || gt(compver, setMin)) {
+                setMin = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            /* istanbul ignore next */
+            default:
+              throw new Error(`Unexpected operation: ${comparator.operator}`);
+          }
+        });
+        if (setMin && (!minver || gt(minver, setMin))) {
+          minver = setMin;
+        }
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    };
+    module.exports = minVersion;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var validRange2 = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module.exports = validRange2;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/outside.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var Range = require_range();
+    var satisfies2 = require_satisfies();
+    var gt = require_gt();
+    var lt = require_lt();
+    var lte = require_lte();
+    var gte = require_gte();
+    var outside = (version, range, hilo, options) => {
+      version = new SemVer(version, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies2(version, range, options)) {
+        return false;
+      }
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    module.exports = outside;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/gtr.js"(exports, module) {
+    "use strict";
+    var outside = require_outside();
+    var gtr = (version, range, options) => outside(version, range, ">", options);
+    module.exports = gtr;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/ltr.js"(exports, module) {
+    "use strict";
+    var outside = require_outside();
+    var ltr = (version, range, options) => outside(version, range, "<", options);
+    module.exports = ltr;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/intersects.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var intersects = (r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    };
+    module.exports = intersects;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/simplify.js"(exports, module) {
+    "use strict";
+    var satisfies2 = require_satisfies();
+    var compare = require_compare();
+    module.exports = (versions, range, options) => {
+      const set = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version of v) {
+        const included = satisfies2(version, range, options);
+        if (included) {
+          prev = version;
+          if (!first) {
+            first = version;
+          }
+        } else {
+          if (prev) {
+            set.push([first, prev]);
+          }
+          prev = null;
+          first = null;
+        }
+      }
+      if (first) {
+        set.push([first, null]);
+      }
+      const ranges = [];
+      for (const [min, max] of set) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
+          ranges.push("*");
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
+          ranges.push(`<=${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
+      }
+      const simplified = ranges.join(" || ");
+      const original = typeof range.raw === "string" ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/subset.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var satisfies2 = require_satisfies();
+    var compare = require_compare();
+    var subset = (sub, dom, options = {}) => {
+      if (sub === dom) {
+        return true;
+      }
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+    var minimumVersion = [new Comparator(">=0.0.0")];
+    var simpleSubset = (sub, dom, options) => {
+      if (sub === dom) {
+        return true;
+      }
+      if (sub.length === 1 && sub[0].semver === ANY) {
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          return true;
+        } else if (options.includePrerelease) {
+          sub = minimumVersionWithPreRelease;
+        } else {
+          sub = minimumVersion;
+        }
+      }
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        if (options.includePrerelease) {
+          return true;
+        } else {
+          dom = minimumVersion;
+        }
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) {
+        if (c.operator === ">" || c.operator === ">=") {
+          gt = higherGT(gt, c, options);
+        } else if (c.operator === "<" || c.operator === "<=") {
+          lt = lowerLT(lt, c, options);
+        } else {
+          eqSet.add(c.semver);
+        }
+      }
+      if (eqSet.size > 1) {
+        return null;
+      }
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) {
+          return null;
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+          return null;
+        }
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies2(eq, String(gt), options)) {
+          return null;
+        }
+        if (lt && !satisfies2(eq, String(lt), options)) {
+          return null;
+        }
+        for (const c of dom) {
+          if (!satisfies2(eq, String(c), options)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+        needDomLTPre = false;
+      }
+      for (const c of dom) {
+        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+              needDomGTPre = false;
+            }
+          }
+          if (c.operator === ">" || c.operator === ">=") {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) {
+              return false;
+            }
+          } else if (gt.operator === ">=" && !satisfies2(gt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+              needDomLTPre = false;
+            }
+          }
+          if (c.operator === "<" || c.operator === "<=") {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) {
+              return false;
+            }
+          } else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
+          return false;
+        }
+      }
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
+        return false;
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
+        return false;
+      }
+      if (needDomGTPre || needDomLTPre) {
+        return false;
+      }
+      return true;
+    };
+    var higherGT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+    };
+    var lowerLT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+    };
+    module.exports = subset;
+  }
+});
+// ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js"(exports, module) {
+    "use strict";
+    var internalRe = require_re();
+    var constants = require_constants();
+    var SemVer = require_semver();
+    var identifiers = require_identifiers();
+    var parse = require_parse();
+    var valid2 = require_valid();
+    var clean = require_clean();
+    var inc = require_inc();
+    var diff = require_diff();
+    var major = require_major();
+    var minor = require_minor();
+    var patch = require_patch();
+    var prerelease = require_prerelease();
+    var compare = require_compare();
+    var rcompare2 = require_rcompare();
+    var compareLoose = require_compare_loose();
+    var compareBuild = require_compare_build();
+    var sort = require_sort();
+    var rsort = require_rsort();
+    var gt = require_gt();
+    var lt = require_lt();
+    var eq = require_eq();
+    var neq = require_neq();
+    var gte = require_gte();
+    var lte = require_lte();
+    var cmp = require_cmp();
+    var coerce = require_coerce();
+    var Comparator = require_comparator();
+    var Range = require_range();
+    var satisfies2 = require_satisfies();
+    var toComparators = require_to_comparators();
+    var maxSatisfying = require_max_satisfying();
+    var minSatisfying = require_min_satisfying();
+    var minVersion = require_min_version();
+    var validRange2 = require_valid2();
+    var outside = require_outside();
+    var gtr = require_gtr();
+    var ltr = require_ltr();
+    var intersects = require_intersects();
+    var simplifyRange = require_simplify();
+    var subset = require_subset();
+    module.exports = {
+      parse,
+      valid: valid2,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare: rcompare2,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      eq,
+      neq,
+      gte,
+      lte,
+      cmp,
+      coerce,
+      Comparator,
+      Range,
+      satisfies: satisfies2,
+      toComparators,
+      maxSatisfying,
+      minSatisfying,
+      minVersion,
+      validRange: validRange2,
+      outside,
+      gtr,
+      ltr,
+      intersects,
+      simplifyRange,
+      subset,
+      SemVer,
+      re: internalRe.re,
+      src: internalRe.src,
+      tokens: internalRe.t,
+      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  }
+});
+// src/module-artifact.ts
+import { parse as parseYaml2 } from "yaml";
+import { createHash } from "node:crypto";
+import { lstat, readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+// ../kernel/src/errors.ts
+var RegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RegistryError";
+    this.code = code;
+  }
+};
+// ../kernel/src/module-compatibility.ts
+var import_semver = __toESM(require_semver2(), 1);
+var PLATFORM_API_VERSION = "0.1.0";
+function satisfiesModuleVersion(version, range) {
+  return (0, import_semver.valid)(version) !== null && (0, import_semver.validRange)(range) !== null && (0, import_semver.satisfies)(version, range);
+}
+function compareModuleVersions(left, right) {
+  return (0, import_semver.rcompare)(left, right);
+}
+function assertModuleCompatibility(manifest, platformVersion = PLATFORM_API_VERSION) {
+  if (!(0, import_semver.valid)(manifest.version))
+    throw new RegistryError(
+      "MODULE_VERSION_INVALID",
+      `Invalid version for ${manifest.id}: ${manifest.version}`
+    );
+  if (manifest.platformApi !== void 0 && (!(0, import_semver.validRange)(manifest.platformApi) || platformVersion !== null && !satisfiesModuleVersion(platformVersion, manifest.platformApi))) {
+    throw new RegistryError(
+      "MODULE_PLATFORM_INCOMPATIBLE",
+      `${manifest.id} requires platform API ${manifest.platformApi}; available ${PLATFORM_API_VERSION}.`
+    );
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const dependency of manifest.dependencies) {
+    if (!dependency.range.trim() || !(0, import_semver.validRange)(dependency.range))
+      throw new RegistryError(
+        "MODULE_RANGE_INVALID",
+        `${manifest.id} declares an invalid range for ${dependency.id}: ${dependency.range}`
+      );
+    if (ids.has(dependency.id))
+      throw new RegistryError(
+        "MODULE_DEPENDENCY_DUPLICATE",
+        `${manifest.id} declares ${dependency.id} more than once.`
+      );
+    ids.add(dependency.id);
+  }
+}
+function assertModuleDependency(consumer, dependency, version) {
+  if (!satisfiesModuleVersion(version, dependency.range)) {
+    throw new RegistryError(
+      "MODULE_DEPENDENCY_INCOMPATIBLE",
+      `${consumer} requires ${dependency.id} ${dependency.range}; available ${version}.`
+    );
+  }
+}
+// ../kernel/src/module-registry.ts
+function compareModules(left, right) {
+  return left.manifest.id.localeCompare(right.manifest.id);
+}
+function visitModule(id, modules, visiting, visited, ordered) {
+  if (visited.has(id)) return;
+  if (visiting.has(id)) {
+    throw new RegistryError(
+      "MODULE_DEPENDENCY_CYCLE",
+      `Dependency cycle detected at "${id}".`
+    );
+  }
+  const current = modules.get(id);
+  if (!current) {
+    throw new RegistryError(
+      "MODULE_NOT_FOUND",
+      `Module "${id}" is not registered.`
+    );
+  }
+  visiting.add(id);
+  for (const dependency of [...current.manifest.dependencies].sort(
+    (a, b) => a.id.localeCompare(b.id)
+  )) {
+    if (!modules.has(dependency.id)) {
+      throw new RegistryError(
+        "MODULE_DEPENDENCY_MISSING",
+        `Module "${id}" requires missing module "${dependency.id}".`
+      );
+    }
+    assertModuleDependency(
+      id,
+      dependency,
+      modules.get(dependency.id).manifest.version
+    );
+    visitModule(dependency.id, modules, visiting, visited, ordered);
+  }
+  visiting.delete(id);
+  visited.add(id);
+  ordered.push(current);
+}
+function createModuleRegistry(input) {
+  const byId = /* @__PURE__ */ new Map();
+  const navigationIds = /* @__PURE__ */ new Set();
+  for (const module of input) {
+    assertModuleCompatibility(module.manifest);
+    if (byId.has(module.manifest.id)) {
+      throw new RegistryError(
+        "MODULE_DUPLICATE",
+        `Module "${module.manifest.id}" is registered more than once.`
+      );
+    }
+    byId.set(module.manifest.id, module);
+    for (const item of module.navigation ?? []) {
+      if (navigationIds.has(item.id)) {
+        throw new RegistryError(
+          "NAVIGATION_DUPLICATE",
+          `Navigation contribution "${item.id}" is registered more than once.`
+        );
+      }
+      navigationIds.add(item.id);
+    }
+  }
+  const ordered = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  for (const module of [...input].sort(compareModules)) {
+    visitModule(module.manifest.id, byId, visiting, visited, ordered);
+  }
+  return Object.freeze({
+    modules: Object.freeze(ordered),
+    get: (id) => byId.get(id),
+    has: (id) => byId.has(id),
+    navigation: (permissions) => Object.freeze(
+      ordered.flatMap((module) => module.navigation ?? []).filter(
+        (item) => !item.permission || permissions?.has(item.permission)
+      ).sort(
+        (left, right) => (left.order ?? 1e3) - (right.order ?? 1e3) || left.id.localeCompare(right.id)
+      )
+    )
+  });
+}
+// ../contracts/schemas/blueprint.schema.json
+var blueprint_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/blueprint.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "id",
+    "version",
+    "architecture",
+    "risk",
+    "owner",
+    "agentRoles",
+    "executorProfiles",
+    "requiredReviewers",
+    "requiresApprovedSpec",
+    "status"
+  ],
+  properties: {
+    $schema: { type: "string" },
+    schemaVersion: { const: 1 },
+    id: { type: "string", pattern: "^[a-z][a-z0-9-]+$" },
+    version: { type: "string", pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
+    architecture: { type: "string", minLength: 1 },
+    risk: {
+      enum: ["read", "workspace-write", "process", "external", "destructive"]
+    },
+    owner: { type: "string", minLength: 1 },
+    agentRoles: {
+      type: "array",
+      minItems: 1,
+      items: { type: "string" },
+      uniqueItems: true
+    },
+    executorProfiles: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true
+    },
+    requiredReviewers: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true
+    },
+    requiresApprovedSpec: { type: "boolean" },
+    status: { enum: ["draft", "approved", "deprecated"] }
+  }
+};
+// ../contracts/schemas/cli-extension.schema.json
+var cli_extension_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/cli-extension.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: ["protocolVersion", "moduleId", "commands"],
+  properties: {
+    protocolVersion: { const: 1 },
+    moduleId: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+    },
+    commands: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["path", "capability"],
+        properties: {
+          path: {
+            type: "array",
+            minItems: 2,
+            items: {
+              type: "string",
+              pattern: "^[a-z][a-z0-9-]*$"
+            }
+          },
+          capability: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+              "id",
+              "version",
+              "summary",
+              "risk",
+              "requiresApprovedSpec",
+              "supportsDryRun"
+            ],
+            properties: {
+              id: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+              },
+              version: { type: "integer", minimum: 1 },
+              summary: {
+                type: "string",
+                minLength: 1,
+                maxLength: 240
+              },
+              risk: {
+                enum: [
+                  "read",
+                  "workspace-write",
+                  "process",
+                  "external",
+                  "destructive"
+                ]
+              },
+              requiresApprovedSpec: { type: "boolean" },
+              supportsDryRun: { type: "boolean" },
+              localOnly: { type: "boolean" },
+              confirmation: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9-]{2,63}$"
+              }
+            },
+            allOf: [
+              {
+                if: {
+                  properties: {
+                    risk: { const: "destructive" },
+                    localOnly: { const: true }
+                  },
+                  required: ["risk", "localOnly"]
+                },
+                then: {
+                  properties: {
+                    confirmation: true,
+                    supportsDryRun: { const: true }
+                  },
+                  required: ["confirmation"]
+                }
+              }
+            ]
+          }
+        }
+      }
+    }
+  }
+};
+// ../contracts/schemas/module.schema.json
+var module_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/module.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "id",
+    "package",
+    "version",
+    "profile",
+    "capabilities",
+    "dependencies",
+    "tenancy",
+    "locales",
+    "stability"
+  ],
+  properties: {
+    $schema: {
+      type: "string"
+    },
+    schemaVersion: {
+      const: 1
+    },
+    id: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+    },
+    package: {
+      type: "string",
+      pattern: "^(@[a-z0-9][a-z0-9._-]*/)?[a-z0-9][a-z0-9._-]*$"
+    },
+    version: {
+      type: "string",
+      pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+    },
+    profile: {
+      enum: ["full", "headless", "ui", "integration"]
+    },
+    capabilities: {
+      type: "array",
+      items: {
+        enum: [
+          "api",
+          "database",
+          "client",
+          "translations",
+          "integration",
+          "cli"
+        ]
+      },
+      uniqueItems: true
+    },
+    dependencies: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "range"],
+        properties: {
+          id: {
+            type: "string",
+            pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+          },
+          range: {
+            type: "string",
+            minLength: 1
+          }
+        }
+      }
+    },
+    tenancy: {
+      enum: ["required", "optional", "none"]
+    },
+    locales: {
+      type: "array",
+      items: {
+        type: "string",
+        pattern: "^[a-z]{2}(-[A-Z]{2})?$"
+      },
+      uniqueItems: true
+    },
+    stability: {
+      enum: ["experimental", "stable", "deprecated"]
+    },
+    platform: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        server: {
+          type: "boolean"
+        },
+        client: {
+          type: "boolean"
+        }
+      }
+    },
+    cli: {
+      type: "object",
+      additionalProperties: false,
+      required: ["catalog", "entry"],
+      properties: {
+        catalog: {
+          type: "string",
+          pattern: "^src/cli/[a-z0-9-/]+\\.json$"
+        },
+        entry: {
+          type: "string",
+          pattern: "^src/cli/[a-z0-9-/]+\\.ts$"
+        }
+      }
+    },
+    platformApi: {
+      type: "string",
+      minLength: 1
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          capabilities: {
+            type: "array",
+            contains: {
+              const: "cli"
+            }
+          }
+        }
+      },
+      then: {
+        properties: {
+          cli: true
+        },
+        required: ["cli"]
+      }
+    },
+    {
+      if: {
+        properties: {
+          cli: true
+        },
+        required: ["cli"]
+      },
+      then: {
+        properties: {
+          capabilities: {
+            type: "array",
+            contains: {
+              const: "cli"
+            }
+          }
+        }
+      }
+    }
+  ]
+};
+// ../contracts/schemas/module-spec.schema.json
+var module_spec_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/module-spec.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "id",
+    "specVersion",
+    "status",
+    "name",
+    "description",
+    "profile",
+    "capabilities",
+    "dependencies",
+    "tenancy",
+    "locales"
+  ],
+  properties: {
+    $schema: { type: "string" },
+    schemaVersion: { const: 1 },
+    id: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+    },
+    specVersion: {
+      type: "string",
+      pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+    },
+    status: {
+      enum: ["draft", "in-review", "approved", "implemented", "deprecated"]
+    },
+    name: { type: "string", minLength: 1 },
+    description: { type: "string", minLength: 1 },
+    profile: { enum: ["full", "headless", "ui", "integration"] },
+    capabilities: {
+      type: "array",
+      items: {
+        enum: [
+          "api",
+          "database",
+          "client",
+          "translations",
+          "integration",
+          "cli"
+        ]
+      },
+      uniqueItems: true
+    },
+    dependencies: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "range"],
+        properties: {
+          id: { type: "string" },
+          range: { type: "string" }
+        }
+      }
+    },
+    tenancy: { enum: ["required", "optional", "none"] },
+    locales: {
+      type: "array",
+      minItems: 1,
+      items: { type: "string" },
+      uniqueItems: true
+    },
+    invariants: {
+      type: "array",
+      items: { type: "string", minLength: 1 },
+      uniqueItems: true
+    },
+    permissions: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "description"],
+        properties: {
+          id: {
+            type: "string",
+            pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+          },
+          description: { type: "string", minLength: 1 }
+        }
+      },
+      uniqueItems: true
+    },
+    dataOwnership: {
+      type: "array",
+      items: { type: "string", minLength: 1 },
+      uniqueItems: true
+    },
+    acceptanceScenarios: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "given", "when", "then"],
+        properties: {
+          id: { type: "string", pattern: "^[A-Z][A-Z0-9-]+$" },
+          given: { type: "string", minLength: 1 },
+          when: { type: "string", minLength: 1 },
+          then: { type: "string", minLength: 1 }
+        }
+      },
+      uniqueItems: true
+    }
+  }
+};
+// ../contracts/schemas/platform-spec.schema.json
+var platform_spec_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/platform-spec.schema.json",
+  type: "object",
+  required: ["schemaVersion", "id", "version", "status"],
+  properties: {
+    schemaVersion: { const: 1 },
+    id: {
+      type: "string",
+      pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)*$"
+    },
+    version: { type: "string", pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
+    status: {
+      enum: ["draft", "in-review", "approved", "implemented", "deprecated"]
+    }
+  }
+};
+// ../contracts/schemas/project.schema.json
+var project_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/project.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "schemaVersion",
+    "architectureVersion",
+    "specs",
+    "modules",
+    "locales",
+    "agent"
+  ],
+  properties: {
+    $schema: {
+      type: "string"
+    },
+    schemaVersion: {
+      const: 1
+    },
+    architectureVersion: {
+      type: "string",
+      pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+    },
+    specs: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "platformRoot",
+        "moduleDirectory"
+      ],
+      properties: {
+        platformRoot: {
+          type: "string",
+          minLength: 1
+        },
+        moduleDirectory: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    modules: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "roots",
+        "enabled"
+      ],
+      properties: {
+        roots: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            minLength: 1
+          },
+          uniqueItems: true
+        },
+        enabled: {
+          type: "array",
+          items: {
+            type: "string",
+            pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+          },
+          uniqueItems: true
+        }
+      }
+    },
+    locales: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "string",
+        pattern: "^[a-z]{2}(-[A-Z]{2})?$"
+      },
+      uniqueItems: true
+    },
+    agent: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "policy",
+        "blueprints",
+        "modelRouting"
+      ],
+      properties: {
+        policy: {
+          type: "string",
+          minLength: 1
+        },
+        blueprints: {
+          type: "string",
+          minLength: 1
+        },
+        modelRouting: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    sandbox: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        delivery: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            default: {
+              $ref: "#/$defs/deliveryTarget"
+            },
+            targets: {
+              type: "array",
+              minItems: 1,
+              items: {
+                $ref: "#/$defs/deliveryTarget"
+              },
+              uniqueItems: true
+            },
+            git: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                remote: {
+                  $ref: "#/$defs/gitName"
+                },
+                repository: {
+                  $ref: "#/$defs/githubRepository"
+                },
+                baseBranch: {
+                  $ref: "#/$defs/gitName"
+                },
+                branchPrefix: {
+                  $ref: "#/$defs/gitName"
+                },
+                provider: {
+                  enum: [
+                    "github",
+                    "none"
+                  ]
+                },
+                mode: {
+                  enum: [
+                    "auto",
+                    "direct",
+                    "fork"
+                  ]
+                },
+                forkOwner: {
+                  $ref: "#/$defs/githubAccount"
+                },
+                reviewers: {
+                  type: "array",
+                  maxItems: 20,
+                  items: {
+                    $ref: "#/$defs/githubAccount"
+                  },
+                  uniqueItems: true
+                }
+              }
+            },
+            maxChangedFiles: {
+              type: "integer",
+              minimum: 1
+            }
+          }
+        }
+      }
+    },
+    web: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "mounts"
+      ],
+      properties: {
+        mounts: {
+          type: "array",
+          maxItems: 256,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+              "id",
+              "moduleId",
+              "surfaceId",
+              "path",
+              "tenantId"
+            ],
+            properties: {
+              id: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9-]*$"
+              },
+              moduleId: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9-]*(\\.[a-z][a-z0-9-]*)+$"
+              },
+              surfaceId: {
+                type: "string",
+                pattern: "^[a-z][a-z0-9-]*$"
+              },
+              path: {
+                type: "string",
+                maxLength: 256,
+                pattern: "^(/|/[a-z0-9-]+(/[a-z0-9-]+)*)$"
+              },
+              tenantId: {
+                type: "string",
+                minLength: 1,
+                maxLength: 128
+              },
+              enabled: {
+                type: "boolean"
+              }
+            }
+          }
+        }
+      }
+    },
+    application: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "path"
+      ],
+      properties: {
+        path: {
+          type: "string",
+          pattern: "^/[a-z][a-z0-9-]*$",
+          not: {
+            enum: [
+              "/auth",
+              "/api",
+              "/sites",
+              "/sign-in",
+              "/sign-up",
+              "/forgot-password",
+              "/reset-password",
+              "/accept-invitation"
+            ]
+          }
+        }
+      }
+    }
+  },
+  $defs: {
+    deliveryTarget: {
+      enum: [
+        "workspace",
+        "git-pr",
+        "official-modules"
+      ]
+    },
+    gitName: {
+      type: "string",
+      maxLength: 120,
+      pattern: "^[A-Za-z0-9][A-Za-z0-9._/-]*$"
+    },
+    githubRepository: {
+      type: "string",
+      pattern: "^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})/[A-Za-z0-9._-]{1,100}$"
+    },
+    githubAccount: {
+      type: "string",
+      pattern: "^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$"
+    }
+  }
+};
+// ../contracts/schemas/module-catalog.schema.json
+var module_catalog_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/module-catalog.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: ["schemaVersion", "releases"],
+  properties: {
+    schemaVersion: {
+      const: 1
+    },
+    releases: {
+      type: "array",
+      maxItems: 4096,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "manifest",
+          "artifact",
+          "sha256",
+          "sourceCommit",
+          "license"
+        ],
+        properties: {
+          manifest: {
+            $ref: "https://flowdular.dev/schemas/module.schema.json"
+          },
+          artifact: {
+            type: "string",
+            minLength: 1
+          },
+          sha256: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$"
+          },
+          sourceCommit: {
+            type: "string",
+            pattern: "^[a-f0-9]{40}$"
+          },
+          license: {
+            type: "string",
+            minLength: 1
+          }
+        }
+      }
+    }
+  }
+};
+// ../contracts/schemas/module-artifact.schema.json
+var module_artifact_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://flowdular.dev/schemas/module-artifact.schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: ["schemaVersion", "manifest", "review", "files"],
+  properties: {
+    schemaVersion: {
+      const: 1
+    },
+    manifest: {
+      $ref: "https://flowdular.dev/schemas/module.schema.json"
+    },
+    review: {
+      type: "object",
+      additionalProperties: false,
+      required: ["sourceSha256", "requirements", "findings", "checks"],
+      properties: {
+        sourceSha256: {
+          type: "string",
+          pattern: "^[a-f0-9]{64}$"
+        },
+        requirements: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        findings: {
+          type: "array",
+          maxItems: 0
+        },
+        checks: {
+          type: "array",
+          minItems: 3,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["name", "command", "exitCode"],
+            properties: {
+              name: {
+                enum: ["typecheck", "test", "validate"]
+              },
+              command: {
+                type: "string",
+                minLength: 1
+              },
+              exitCode: {
+                const: 0
+              }
+            }
+          }
+        }
+      }
+    },
+    files: {
+      type: "array",
+      maxItems: 4096,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["path", "content", "sha256"],
+        properties: {
+          path: {
+            type: "string",
+            minLength: 1,
+            maxLength: 239
+          },
+          content: {
+            type: "string"
+          },
+          sha256: {
+            type: "string",
+            pattern: "^[a-f0-9]{64}$"
+          }
+        }
+      }
+    }
+  }
+};
+// ../contracts/src/schemas.ts
+var blueprintSchema = blueprint_schema_default;
+var cliExtensionSchema = cli_extension_schema_default;
+var moduleSchema = module_schema_default;
+var moduleSpecSchema = module_spec_schema_default;
+var platformSpecSchema = platform_spec_schema_default;
+var projectSchema = project_schema_default;
+var moduleCatalogSchema = module_catalog_schema_default;
+var moduleArtifactSchema = module_artifact_schema_default;
+// src/validation.ts
+import { readdir, readFile } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import Ajv2020 from "ajv/dist/2020.js";
+import { parse as parseYaml } from "yaml";
+var ajv = new Ajv2020({ allErrors: true, strict: true });
+var validators = {
+  application: ajv.compile(projectSchema.properties.application),
+  web: ajv.compile(projectSchema.properties.web),
+  project: ajv.compile(projectSchema),
+  module: ajv.compile(moduleSchema),
+  moduleCatalog: ajv.compile(moduleCatalogSchema),
+  moduleArtifact: ajv.compile(moduleArtifactSchema),
+  moduleSpec: ajv.compile(moduleSpecSchema),
+  blueprint: ajv.compile(blueprintSchema),
+  cliExtension: ajv.compile(cliExtensionSchema),
+  platformSpec: ajv.compile(platformSpecSchema)
+};
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".flowdular",
+  ".coreloom",
+  "node_modules",
+  "dist"
+]);
+async function findNamedFiles(root, name) {
+  const matches = [];
+  async function visit(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      if (SKIPPED_DIRECTORIES.has(entry.name)) continue;
+      const path = join(directory, entry.name);
+      if (entry.isDirectory()) await visit(path);
+      else if (entry.name === name) matches.push(path);
+    }
+  }
+  await visit(root);
+  return matches.sort();
+}
+// src/module-artifact.ts
+var MAX_ARTIFACT_BYTES = 48 * 1024 * 1024;
+var MAX_SOURCE_BYTES = 32 * 1024 * 1024;
+var MAX_FILES = 4096;
+var hashBytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var HASH = /^[a-f0-9]{64}$/;
+var ROOTS = /* @__PURE__ */ new Set(["src", "tests", "migrations", "translations", "spec"]);
+var ROOT_FILES = /* @__PURE__ */ new Set([
+  "module.json",
+  "package.json",
+  "README.md",
+  "CHANGELOG.md",
+  "LICENSE",
+  "tsconfig.json",
+  "vitest.config.ts"
+]);
+var ModuleDistributionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function distributionAssert(condition, code, message) {
+  if (!condition) throw new ModuleDistributionError(code, message);
+}
+function safeSourcePath(path) {
+  const parts = path.split("/");
+  return path.length < 240 && /^[a-zA-Z0-9_./@+ -]+$/.test(path) && parts.every(
+    (part) => part && part !== "." && part !== ".." && !part.startsWith(".") && part !== "node_modules" && part !== "dist"
+  ) && (parts.length === 1 ? ROOT_FILES.has(path) : ROOTS.has(parts[0]));
+}
+function sourceDigest(files) {
+  return hashBytes(
+    JSON.stringify(
+      [...files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0).map((file) => [file.path, file.sha256])
+    )
+  );
+}
+async function readModuleSource(root) {
+  const files = [];
+  let size = 0;
+  async function visit(directory, prefix) {
+    for (const entry of await readdir2(directory, { withFileTypes: true })) {
+      const path = prefix + entry.name;
+      if (!prefix && !ROOT_FILES.has(path) && !ROOTS.has(path)) continue;
+      distributionAssert(
+        !entry.isSymbolicLink(),
+        "MODULE_SOURCE_LINK",
+        `Module source contains a link: ${path}`
+      );
+      if (entry.isDirectory()) {
+        distributionAssert(
+          !entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "dist",
+          "MODULE_SOURCE_PATH",
+          `Unexpected module directory: ${path}`
+        );
+        await visit(join2(directory, entry.name), path + "/");
+      } else {
+        distributionAssert(
+          entry.isFile() && safeSourcePath(path),
+          "MODULE_SOURCE_PATH",
+          `Unexpected module source: ${path}`
+        );
+        const stat2 = await lstat(join2(directory, entry.name));
+        distributionAssert(
+          size + stat2.size <= MAX_SOURCE_BYTES && files.length < MAX_FILES,
+          "MODULE_SOURCE_LIMIT",
+          "Module source is too large."
+        );
+        const bytes = await readFile2(join2(directory, entry.name));
+        size += bytes.length;
+        files.push({
+          path,
+          content: bytes.toString("base64"),
+          sha256: hashBytes(bytes)
+        });
+      }
+    }
+  }
+  distributionAssert(
+    !(await lstat(root)).isSymbolicLink(),
+    "MODULE_SOURCE_LINK",
+    "Module root cannot be a link."
+  );
+  await visit(root, "");
+  return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+function validateModuleArtifact(value) {
+  const artifact = value;
+  distributionAssert(
+    validators.moduleArtifact(artifact) && artifact && artifact.schemaVersion === 1 && Array.isArray(artifact.files) && artifact.files.length <= MAX_FILES && validators.module(artifact.manifest),
+    "MODULE_ARTIFACT_INVALID",
+    "Invalid module artifact."
+  );
+  assertModuleCompatibility(artifact.manifest);
+  distributionAssert(
+    artifact.manifest.platformApi,
+    "MODULE_PLATFORM_REQUIRED",
+    "Distributed modules must declare platformApi."
+  );
+  const paths = /* @__PURE__ */ new Set();
+  let size = 0;
+  for (const file of artifact.files) {
+    distributionAssert(
+      file && typeof file.path === "string" && safeSourcePath(file.path) && typeof file.content === "string" && typeof file.sha256 === "string" && HASH.test(file.sha256),
+      "MODULE_ARTIFACT_PATH",
+      "Invalid artifact file."
+    );
+    const key = file.path.toLowerCase();
+    distributionAssert(
+      !paths.has(key),
+      "MODULE_ARTIFACT_COLLISION",
+      `Duplicate file: ${file.path}`
+    );
+    paths.add(key);
+    const bytes = Buffer.from(file.content, "base64");
+    size += bytes.length;
+    distributionAssert(
+      bytes.toString("base64") === file.content && hashBytes(bytes) === file.sha256 && size <= MAX_SOURCE_BYTES,
+      "MODULE_ARTIFACT_DIGEST",
+      `Invalid content: ${file.path}`
+    );
+  }
+  for (const path of paths)
+    for (const parent of path.split("/").slice(0, -1).map(
+      (_, i) => path.split("/").slice(0, i + 1).join("/")
+    ))
+      distributionAssert(
+        !paths.has(parent),
+        "MODULE_ARTIFACT_COLLISION",
+        `File/directory collision: ${path}`
+      );
+  function json(path) {
+    const file = artifact.files.find((file2) => file2.path === path);
+    distributionAssert(
+      file,
+      "MODULE_ARTIFACT_MISSING",
+      `Artifact is missing ${path}.`
+    );
+    return JSON.parse(
+      Buffer.from(file.content, "base64").toString("utf8")
+    );
+  }
+  const manifest = json("module.json");
+  const pkg = json("package.json");
+  distributionAssert(
+    JSON.stringify(manifest) === JSON.stringify(artifact.manifest) && pkg.name === artifact.manifest.package && pkg.version === artifact.manifest.version && paths.has("spec/module.yaml"),
+    "MODULE_ARTIFACT_IDENTITY",
+    "Artifact identity does not match source/package/spec."
+  );
+  for (const section of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ]) {
+    const dependencies = pkg[section] ?? {};
+    distributionAssert(
+      Object.values(dependencies).every(
+        (value2) => typeof value2 === "string" && !/^(workspace:|file:|link:)/.test(value2)
+      ),
+      "MODULE_NONPORTABLE_DEPENDENCY",
+      "Distributed module dependencies must resolve outside the authoring workspace."
+    );
+  }
+  const specFile = artifact.files.find(
+    (file) => file.path === "spec/module.yaml"
+  );
+  const spec = parseYaml2(
+    Buffer.from(specFile.content, "base64").toString("utf8")
+  );
+  distributionAssert(
+    validators.moduleSpec(spec) && spec.id === artifact.manifest.id && spec.specVersion === artifact.manifest.version,
+    "MODULE_SPEC_INVALID",
+    "Module specification is invalid or differs from the released identity."
+  );
+  const scripts = pkg.scripts ?? {};
+  for (const script of ["preinstall", "install", "postinstall", "prepare"])
+    distributionAssert(
+      !(script in scripts),
+      "MODULE_INSTALL_SCRIPT",
+      `Install lifecycle scripts are forbidden: ${script}`
+    );
+  const review = artifact.review;
+  distributionAssert(
+    review && review.sourceSha256 === sourceDigest(artifact.files) && Array.isArray(review.findings) && review.findings.length === 0 && Array.isArray(review.requirements) && review.requirements.length > 0 && review.requirements.every(
+      (item) => typeof item === "string" && item.trim()
+    ) && Array.isArray(review.checks),
+    "MODULE_REVIEW_INVALID",
+    "Missing, stale or failing review evidence."
+  );
+  for (const name of ["typecheck", "test", "validate"])
+    distributionAssert(
+      review.checks.some(
+        (check) => check && check.name === name && check.exitCode === 0 && typeof check.command === "string" && check.command.trim()
+      ),
+      "MODULE_REVIEW_INVALID",
+      `Missing passing ${name} evidence.`
+    );
+  distributionAssert(
+    review.checks.every((check) => check.exitCode === 0),
+    "MODULE_REVIEW_INVALID",
+    "Review contains a failing check."
+  );
+  return artifact;
+}
+async function packModule(root, review) {
+  const files = await readModuleSource(root);
+  const file = files.find((file2) => file2.path === "module.json");
+  distributionAssert(
+    file,
+    "MODULE_ARTIFACT_MISSING",
+    "module.json is missing."
+  );
+  const manifest = JSON.parse(
+    Buffer.from(file.content, "base64").toString("utf8")
+  );
+  return validateModuleArtifact({ schemaVersion: 1, manifest, files, review });
+}
+// src/module-catalog.ts
+import { readFile as readFile4, stat } from "node:fs/promises";
+import { dirname as dirname3, resolve as resolve2 } from "node:path";
+// src/workspace.ts
+import { access, readFile as readFile3, realpath } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute, relative as relative2, resolve } from "node:path";
+function resolveInside(root, candidate) {
+  const absolute = isAbsolute(candidate) ? resolve(candidate) : resolve(root, candidate);
+  const pathFromRoot = relative2(root, absolute);
+  if (pathFromRoot.startsWith("..") || isAbsolute(pathFromRoot)) {
+    throw new Error(`Path escapes the workspace: ${candidate}`);
+  }
+  return absolute;
+}
+async function resolveExistingInside(root, candidate) {
+  const canonicalRoot = await realpath(root);
+  const canonicalCandidate = await realpath(resolveInside(root, candidate));
+  const pathFromRoot = relative2(canonicalRoot, canonicalCandidate);
+  if (pathFromRoot.startsWith("..") || isAbsolute(pathFromRoot)) {
+    throw new Error(`Path escapes the workspace through a link: ${candidate}`);
+  }
+  return canonicalCandidate;
+}
+// src/module-catalog.ts
+var OFFICIAL_CATALOG = "https://raw.githubusercontent.com/Flowdular/official-modules/main/registry/index.json";
+var OFFICIAL_PREFIX = "https://raw.githubusercontent.com/Flowdular/official-modules/";
+async function boundedRead(location, limit, fetcher = fetch) {
+  if (!location.startsWith("https://")) {
+    distributionAssert(
+      (await stat(location)).size <= limit,
+      "MODULE_DOWNLOAD_LIMIT",
+      "Module metadata/artifact exceeds the size limit."
+    );
+    const result = await readFile4(location);
+    distributionAssert(
+      result.length <= limit,
+      "MODULE_DOWNLOAD_LIMIT",
+      "Module file grew beyond the size limit."
+    );
+    return result;
+  }
+  distributionAssert(
+    location.startsWith(OFFICIAL_PREFIX),
+    "MODULE_SOURCE_UNTRUSTED",
+    "Only the official HTTPS publisher is supported. Use an explicit local catalog for offline releases."
+  );
+  const response = await fetcher(location, {
+    redirect: "error",
+    signal: AbortSignal.timeout(3e4)
+  });
+  distributionAssert(
+    response.ok && response.body,
+    "MODULE_DOWNLOAD_FAILED",
+    `Official module download failed (${response.status}).`
+  );
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      distributionAssert(
+        size <= limit,
+        "MODULE_DOWNLOAD_LIMIT",
+        "Module download exceeds the size limit."
+      );
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel();
+  }
+  return Buffer.concat(chunks);
+}
+async function loadModuleCatalog(location = OFFICIAL_CATALOG, fetcher = fetch) {
+  distributionAssert(
+    location === OFFICIAL_CATALOG || !/^[a-z][a-z0-9+.-]*:/i.test(location),
+    "MODULE_SOURCE_UNTRUSTED",
+    "Use the official catalog or an explicit local catalog path."
+  );
+  const catalog = JSON.parse(
+    (await boundedRead(location, 4 * 1024 * 1024, fetcher)).toString("utf8")
+  );
+  distributionAssert(
+    validators.moduleCatalog(catalog) && catalog && catalog.schemaVersion === 1 && Array.isArray(catalog.releases) && catalog.releases.length <= 4096,
+    "MODULE_CATALOG_INVALID",
+    "Invalid module catalog."
+  );
+  const identities = /* @__PURE__ */ new Set();
+  for (const release of catalog.releases) {
+    distributionAssert(
+      release && validators.module(release.manifest) && /^@flowdular\/module-[a-z0-9-]+$/.test(release.manifest.package) && typeof release.artifact === "string" && /^[a-f0-9]{64}$/.test(release.sha256) && /^[a-f0-9]{40}$/.test(release.sourceCommit) && typeof release.license === "string" && release.license.trim(),
+      "MODULE_CATALOG_INVALID",
+      "Invalid module release."
+    );
+    assertModuleCompatibility(release.manifest, null);
+    distributionAssert(
+      release.manifest.platformApi,
+      "MODULE_PLATFORM_REQUIRED",
+      "Distributed modules must declare platformApi."
+    );
+    const identity = release.manifest.id + "@" + release.manifest.version;
+    distributionAssert(
+      !identities.has(identity),
+      "MODULE_CATALOG_DUPLICATE",
+      `Duplicate release: ${identity}`
+    );
+    identities.add(identity);
+  }
+  return { catalog, location };
+}
+async function releaseLocation(source, release) {
+  if (source.location.startsWith("https://")) {
+    const prefix = OFFICIAL_PREFIX + release.sourceCommit + "/";
+    distributionAssert(
+      release.artifact.startsWith(prefix) && new URL(release.artifact).href === release.artifact && !new URL(release.artifact).search && !new URL(release.artifact).hash,
+      "MODULE_SOURCE_UNTRUSTED",
+      "Release artifact must be pinned to its official source commit."
+    );
+    return release.artifact;
+  }
+  distributionAssert(
+    !/^[a-z][a-z0-9+.-]*:/i.test(release.artifact),
+    "MODULE_SOURCE_UNTRUSTED",
+    "An offline catalog must use local artifacts."
+  );
+  return resolveExistingInside(
+    dirname3(resolve2(source.location)),
+    release.artifact
+  );
+}
+function resolveModuleReleases(catalog, target, installed) {
+  const split = target.lastIndexOf("@");
+  const id = split < 0 ? target : target.slice(0, split);
+  const range = split < 0 ? "*" : target.slice(split + 1);
+  distributionAssert(
+    /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/.test(id) && range,
+    "MODULE_TARGET_INVALID",
+    "Use module.id or module.id@version/range."
+  );
+  const existing = new Map(
+    installed.map((manifest) => [manifest.id, manifest])
+  );
+  const candidates = /* @__PURE__ */ new Map();
+  for (const release of catalog.releases) {
+    const entries = candidates.get(release.manifest.id) ?? [];
+    entries.push(release);
+    candidates.set(release.manifest.id, entries);
+  }
+  for (const entries of candidates.values())
+    entries.sort(
+      (a, b) => compareModuleVersions(a.manifest.version, b.manifest.version)
+    );
+  let attempts = 0;
+  function search(selected2, pending) {
+    distributionAssert(
+      ++attempts <= 1e4 && pending.length <= 4096 && selected2.size <= 256,
+      "MODULE_RESOLUTION_LIMIT",
+      "Module dependency resolution limit exceeded."
+    );
+    const [next, ...rest] = pending;
+    if (!next) return selected2;
+    const fixed = selected2.get(next.id)?.manifest ?? existing.get(next.id);
+    if (fixed)
+      return satisfiesModuleVersion(fixed.version, next.range) ? search(selected2, rest) : void 0;
+    for (const candidate of candidates.get(next.id) ?? []) {
+      if (!satisfiesModuleVersion(candidate.manifest.version, next.range) || !satisfiesModuleVersion(
+        PLATFORM_API_VERSION,
+        candidate.manifest.platformApi
+      ))
+        continue;
+      const found = search(new Map([...selected2, [next.id, candidate]]), [
+        ...candidate.manifest.dependencies,
+        ...rest
+      ]);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  const selected = search(/* @__PURE__ */ new Map(), [{ id, range }]);
+  distributionAssert(
+    selected,
+    "MODULE_RESOLUTION_FAILED",
+    `No compatible dependency closure for ${target}. Installed versions are preserved.`
+  );
+  const all = [
+    ...installed,
+    ...[...selected.values()].map((release) => release.manifest)
+  ];
+  const registry = createModuleRegistry(all.map((manifest) => ({ manifest })));
+  return registry.modules.flatMap((module) => {
+    const release = selected.get(module.manifest.id);
+    return release ? [release] : [];
+  });
+}
+async function readRelease(source, release, fetcher = fetch) {
+  return boundedRead(
+    await releaseLocation(source, release),
+    MAX_ARTIFACT_BYTES,
+    fetcher
+  );
+}
+// src/module-install.ts
+import {
+  lstat as lstat3,
+  mkdir,
+  readFile as readFile8,
+  readdir as readdir4,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { dirname as dirname6, join as join6, relative as relative5 } from "node:path";
+// src/sdk.ts
+import { createRequire } from "node:module";
+import { readFile as readFile5 } from "node:fs/promises";
+import { dirname as dirname4, join as join3 } from "node:path";
+var SDK_VERSION = "0.1.0";
+function npmPackage(specifier) {
+  return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+}
+async function sdkModules(workspace) {
+  const require2 = createRequire(join3(workspace.root, "platform/package.json"));
+  let indexPath;
+  try {
+    indexPath = require2.resolve("@flowdular/sdk/modules.json");
+  } catch (error) {
+    if (["MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"].includes(
+      error.code ?? ""
+    ))
+      return /* @__PURE__ */ new Map();
+    throw error;
+  }
+  const index = JSON.parse(await readFile5(indexPath, "utf8"));
+  if (index.schemaVersion !== 1 || !Array.isArray(index.modules) || index.modules.length > 256)
+    throw new Error("Invalid SDK module index.");
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of index.modules) {
+    if (!/^@flowdular\/sdk\/modules\/[a-z0-9-]+$/.test(entry.import))
+      throw new Error("Invalid SDK module entrypoint.");
+    const path = await resolveExistingInside(
+      dirname4(indexPath),
+      entry.manifest
+    );
+    if (result.has(path)) throw new Error("Duplicate SDK module path.");
+    result.set(path, entry.import);
+  }
+  return result;
+}
+// src/module-files.ts
+import { createRequire as createRequire2 } from "node:module";
+import { lstat as lstat2, readFile as readFile6 } from "node:fs/promises";
+import { join as join4, relative as relative3 } from "node:path";
+function moduleRoots(workspace) {
+  const roots = workspace.config.modules?.roots ?? ["modules"];
+  if (!Array.isArray(roots) || !roots.length || roots.some(
+    (root) => typeof root !== "string" || !root || root.startsWith(".") || root.includes("\\") || root.split("/").some((part) => part === ".." || !part)
+  ))
+    throw new Error(
+      "Invalid modules.roots. Use relative workspace directories."
+    );
+  return roots.map((root) => {
+    const path = resolveInside(workspace.root, root);
+    if (!relative3(workspace.root, path))
+      throw new Error("The workspace root cannot be a module root.");
+    return path;
+  });
+}
+async function findModuleFiles(workspace) {
+  const files = /* @__PURE__ */ new Set();
+  for (const root of moduleRoots(workspace)) {
+    try {
+      await lstat2(root);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    await resolveExistingInside(workspace.root, root);
+    for (const file of await findNamedFiles(root, "module.json")) {
+      if (relative3(root, file).split("/").length === 2) files.add(file);
+    }
+  }
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of files)
+    packages.add(
+      JSON.parse(await readFile6(file, "utf8")).package
+    );
+  for (const file of (await sdkModules(workspace)).keys()) {
+    const manifest = JSON.parse(await readFile6(file, "utf8"));
+    if (!packages.has(manifest.package)) files.add(file);
+  }
+  const platformPackage = join4(workspace.root, "platform/package.json");
+  try {
+    const pkg = JSON.parse(await readFile6(platformPackage, "utf8"));
+    const require2 = createRequire2(platformPackage);
+    for (const name of Object.keys(pkg.dependencies ?? {}).sort()) {
+      if (!name.startsWith("@flowdular/module-") || packages.has(name))
+        continue;
+      let file;
+      try {
+        file = require2.resolve(name + "/module.json");
+      } catch (error) {
+        if (["MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"].includes(
+          error.code ?? ""
+        ))
+          continue;
+        throw error;
+      }
+      files.add(file);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return [...files].sort();
+}
+// src/module-validate.ts
+import { access as access2, readFile as readFile7, readdir as readdir3 } from "node:fs/promises";
+import { dirname as dirname5, join as join5, relative as relative4 } from "node:path";
+import { parse as parseYaml3 } from "yaml";
+function issue(code, message, path, severity = "error") {
+  return { code, message, path, severity };
+}
+async function exists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(path) {
+  return JSON.parse(await readFile7(path, "utf8"));
+}
+async function clientSourceFiles(moduleRoot) {
+  const clientRoot = join5(moduleRoot, "src/client");
+  if (!await exists(clientRoot)) return [];
+  return (await readdir3(clientRoot, {
+    recursive: true,
+    withFileTypes: true
+  })).filter((entry) => entry.isFile() && /\.(?:ts|tsx|tsrx)$/.test(entry.name)).map((entry) => join5(entry.parentPath, entry.name));
+}
+async function platformIssues(moduleRoot, manifest) {
+  const issues = [];
+  let exports = {};
+  let packageName;
+  let packageVersion;
+  try {
+    const pkg = await readJson(join5(moduleRoot, "package.json"));
+    exports = pkg.exports ?? {};
+    packageName = pkg.name;
+    packageVersion = pkg.version;
+  } catch (error) {
+    issues.push(
+      issue(
+        "PACKAGE_MANIFEST_INVALID",
+        `package.json could not be read: ${error instanceof Error ? error.message : String(error)}`,
+        "package.json"
+      )
+    );
+    return issues;
+  }
+  if (packageName !== manifest.package) {
+    issues.push(
+      issue(
+        "PACKAGE_NAME_MISMATCH",
+        `package.json name "${String(packageName)}" differs from module.json package "${manifest.package}".`,
+        "package.json"
+      )
+    );
+  }
+  if (packageVersion !== manifest.version) {
+    issues.push(
+      issue(
+        "PACKAGE_VERSION_MISMATCH",
+        `package.json version "${String(packageVersion)}" differs from module.json version "${manifest.version}".`,
+        "package.json"
+      )
+    );
+  }
+  if (manifest.platform?.server === true) {
+    if (!await exists(join5(moduleRoot, "src/platform.ts"))) {
+      issues.push(
+        issue(
+          "PLATFORM_SERVER_ENTRY_MISSING",
+          "platform.server requires src/platform.ts exporting createServerComposition.",
+          "src/platform.ts"
+        )
+      );
+    }
+    if (!("./platform" in exports)) {
+      issues.push(
+        issue(
+          "PLATFORM_EXPORT_MISSING",
+          'platform.server requires a "./platform" entry in package.json exports.',
+          "package.json"
+        )
+      );
+    }
+  }
+  if (manifest.platform?.client === true) {
+    if (!await exists(join5(moduleRoot, "src/client/index.ts"))) {
+      issues.push(
+        issue(
+          "PLATFORM_CLIENT_ENTRY_MISSING",
+          "platform.client requires src/client/index.ts exporting createClientContribution.",
+          "src/client/index.ts"
+        )
+      );
+    }
+    if (!("./client" in exports)) {
+      issues.push(
+        issue(
+          "PLATFORM_CLIENT_EXPORT_MISSING",
+          'platform.client requires a "./client" entry in package.json exports.',
+          "package.json"
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function specIssues(moduleRoot, manifest, specDirectory) {
+  const specPath = join5(specDirectory, "module.yaml");
+  let spec;
+  try {
+    spec = parseYaml3(
+      await readFile7(join5(moduleRoot, specPath), "utf8")
+    );
+  } catch (error) {
+    return [
+      issue(
+        "SPEC_FILE_MISSING",
+        `Module specification could not be read: ${error instanceof Error ? error.message : String(error)}`,
+        specPath,
+        "warning"
+      )
+    ];
+  }
+  const issues = [];
+  if (spec.id !== manifest.id) {
+    issues.push(
+      issue(
+        "SPEC_ID_MISMATCH",
+        `Specification id "${String(spec.id)}" differs from module.json id "${manifest.id}".`,
+        specPath
+      )
+    );
+  }
+  if (String(spec.specVersion) !== manifest.version) {
+    issues.push(
+      issue(
+        "SPEC_VERSION_DRIFT",
+        `module.json version ${manifest.version} differs from specVersion ${String(spec.specVersion)}.`,
+        specPath,
+        "warning"
+      )
+    );
+  }
+  return issues;
+}
+async function translationIssues(moduleRoot, manifest, projectLocales) {
+  const issues = [];
+  if (projectLocales) {
+    for (const locale of manifest.locales) {
+      if (!projectLocales.includes(locale)) {
+        issues.push(
+          issue(
+            "LOCALE_NOT_IN_PROJECT",
+            `Locale "${locale}" is not listed in flowdular.json locales.`,
+            "module.json",
+            "warning"
+          )
+        );
+      }
+    }
+  }
+  if (!manifest.capabilities.includes("translations")) return issues;
+  const keySets = /* @__PURE__ */ new Map();
+  for (const locale of manifest.locales) {
+    const path = `translations/${locale}.json`;
+    if (!await exists(join5(moduleRoot, path))) {
+      issues.push(
+        issue(
+          "TRANSLATION_FILE_MISSING",
+          `Locale "${locale}" has no ${path}.`,
+          path
+        )
+      );
+      continue;
+    }
+    try {
+      const bundle = await readJson(join5(moduleRoot, path));
+      if (!bundle || typeof bundle !== "object" || Array.isArray(bundle)) {
+        throw new Error("Expected a JSON object.");
+      }
+      keySets.set(locale, Object.keys(bundle).sort());
+    } catch (error) {
+      issues.push(
+        issue(
+          "TRANSLATION_PARSE_ERROR",
+          `${path} is not a JSON object: ${error instanceof Error ? error.message : String(error)}`,
+          path
+        )
+      );
+    }
+  }
+  const [reference, ...others] = [...keySets.entries()];
+  if (!reference) return issues;
+  for (const [locale, keys] of others) {
+    const missing = reference[1].filter((key) => !keys.includes(key));
+    const extra = keys.filter((key) => !reference[1].includes(key));
+    if (missing.length === 0 && extra.length === 0) continue;
+    const detail = [
+      ...missing.length > 0 ? [`missing ${missing.join(", ")}`] : [],
+      ...extra.length > 0 ? [`extra ${extra.join(", ")}`] : []
+    ].join("; ");
+    issues.push(
+      issue(
+        "TRANSLATION_KEYS_MISMATCH",
+        `translations/${locale}.json keys differ from translations/${reference[0]}.json: ${detail}.`,
+        `translations/${locale}.json`
+      )
+    );
+  }
+  const referenceKeys = new Set(reference[1]);
+  const files = await clientSourceFiles(moduleRoot);
+  if (files.length > 0) {
+    const namespace = manifest.id.split(".")[0] ?? manifest.id;
+    const prefix = namespace + ".";
+    const missing = /* @__PURE__ */ new Map();
+    const pattern = /\bt\s*\(\s*(['"])([a-zA-Z0-9._-]+)\1/g;
+    for (const file of files) {
+      const source = await readFile7(file, "utf8");
+      for (const match of source.matchAll(pattern)) {
+        const fullKey = match[2];
+        if (!fullKey.startsWith(prefix) || fullKey.endsWith(".")) continue;
+        const localKey = fullKey.slice(prefix.length);
+        if (!referenceKeys.has(localKey)) {
+          missing.set(fullKey, relative4(moduleRoot, file));
+        }
+      }
+    }
+    for (const [key, path] of [...missing].sort(
+      ([left], [right]) => left.localeCompare(right)
+    )) {
+      issues.push(
+        issue(
+          "TRANSLATION_KEY_MISSING",
+          `Translation key "${key}" is used by the client but absent from translations/${reference[0]}.json.`,
+          path
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function userInterfaceIssues(moduleRoot) {
+  const issues = [];
+  for (const file of await clientSourceFiles(moduleRoot)) {
+    const source = await readFile7(file, "utf8");
+    const path = relative4(moduleRoot, file);
+    if (/<table\b/.test(source)) {
+      issues.push(
+        issue(
+          "RAW_TABLE_FORBIDDEN",
+          "Module screens use Table or TableCard from @flowdular/ui instead of raw table markup.",
+          path
+        )
+      );
+    }
+    if (/from\s+['"]@octanejs\/tanstack-table['"]/.test(source)) {
+      issues.push(
+        issue(
+          "TANSTACK_TABLE_DIRECT_IMPORT",
+          "Modules use the shared Table contract from @flowdular/ui; TanStack configuration belongs to the UI package.",
+          path
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function moduleLayoutIssues(moduleRoot, manifest, options = {}) {
+  return [
+    ...await platformIssues(moduleRoot, manifest),
+    ...await specIssues(
+      moduleRoot,
+      manifest,
+      options.specDirectory ?? "spec"
+    ),
+    ...await translationIssues(moduleRoot, manifest, options.projectLocales),
+    ...await userInterfaceIssues(moduleRoot)
+  ];
+}
+// src/module-install.ts
+var LOCK = "flowdular.modules.lock.json";
+var TRANSACTION = ".flowdular-module-install";
+async function exists2(path) {
+  try {
+    await lstat3(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function safeParents(workspace, path) {
+  const parts = relative5(
+    workspace.root,
+    resolveInside(workspace.root, path)
+  ).split("/");
+  let current = workspace.root;
+  for (const part of parts) {
+    current = join6(current, part);
+    if (!await exists2(current)) break;
+    distributionAssert(
+      !(await lstat3(current)).isSymbolicLink(),
+      "MODULE_DESTINATION_LINK",
+      "Module installation paths cannot contain links."
+    );
+  }
+}
+function validateLock(workspace, value) {
+  const lock = value;
+  distributionAssert(
+    lock && lock.schemaVersion === 1 && Array.isArray(lock.modules) && lock.modules.length <= 256,
+    "MODULE_LOCK_INVALID",
+    "Invalid module lockfile."
+  );
+  const ids = /* @__PURE__ */ new Set();
+  const dirs = /* @__PURE__ */ new Set();
+  for (const entry of lock.modules) {
+    distributionAssert(
+      entry && typeof entry.id === "string" && typeof entry.version === "string" && typeof entry.directory === "string" && entry.files && typeof entry.files === "object" && !Array.isArray(entry.files),
+      "MODULE_LOCK_INVALID",
+      "Invalid installed module entry."
+    );
+    const path = resolveInside(workspace.root, entry.directory);
+    distributionAssert(
+      moduleRoots(workspace).some((root) => dirname6(path) === root) && !ids.has(entry.id) && !dirs.has(path.toLowerCase()),
+      "MODULE_LOCK_INVALID",
+      "Duplicate or invalid installed module path."
+    );
+    ids.add(entry.id);
+    dirs.add(path.toLowerCase());
+    distributionAssert(
+      Object.entries(entry.files).every(
+        ([path2, hash]) => safeSourcePath(path2) && typeof hash === "string" && /^[a-f0-9]{64}$/.test(hash)
+      ),
+      "MODULE_LOCK_INVALID",
+      "Invalid module file hashes."
+    );
+  }
+  return lock;
+}
+async function readLock(workspace) {
+  const path = join6(workspace.root, LOCK);
+  await safeParents(workspace, path);
+  if (!await exists2(path))
+    return { lock: { schemaVersion: 1, modules: [] }, raw: null };
+  const raw = await readFile8(path, "utf8");
+  return { lock: validateLock(workspace, JSON.parse(raw)), raw };
+}
+async function directoryHashes(root) {
+  const hashes = /* @__PURE__ */ Object.create(null);
+  async function visit(directory, prefix) {
+    for (const entry of await readdir4(directory, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git")
+        continue;
+      distributionAssert(
+        !entry.isSymbolicLink(),
+        "MODULE_LOCAL_CHANGES",
+        "Installed module contains a symbolic link."
+      );
+      const path = prefix + entry.name;
+      if (entry.isDirectory())
+        await visit(join6(directory, entry.name), path + "/");
+      else {
+        distributionAssert(
+          entry.isFile(),
+          "MODULE_LOCAL_CHANGES",
+          "Installed module contains a special file."
+        );
+        hashes[path] = hashBytes(await readFile8(join6(directory, entry.name)));
+      }
+    }
+  }
+  await visit(root, "");
+  return hashes;
+}
+function equalHashes(a, b) {
+  return Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([path, hash]) => b[path] === hash);
+}
+async function assertUnmodified(workspace, entry) {
+  const path = resolveInside(workspace.root, entry.directory);
+  await safeParents(workspace, path);
+  distributionAssert(
+    await exists2(path) && equalHashes(await directoryHashes(path), entry.files),
+    "MODULE_LOCAL_CHANGES",
+    `Module ${entry.id} has local changes or is missing. Preserve/merge those changes before updating.`
+  );
+}
+async function validateInstalledModules(workspace) {
+  const { lock, raw } = await readLock(workspace);
+  distributionAssert(
+    raw !== null,
+    "MODULE_LOCK_MISSING",
+    "No module lockfile exists."
+  );
+  for (const entry of lock.modules) {
+    await assertUnmodified(workspace, entry);
+    const manifest = JSON.parse(
+      await readFile8(
+        join6(workspace.root, entry.directory, "module.json"),
+        "utf8"
+      )
+    );
+    distributionAssert(
+      manifest.id === entry.id && manifest.version === entry.version,
+      "MODULE_LOCK_INVALID",
+      "Lock identity differs from the installed manifest."
+    );
+  }
+  return lock;
+}
+async function rollback(workspace, journal) {
+  const transaction = join6(workspace.root, TRANSACTION);
+  validateLock(workspace, {
+    schemaVersion: 1,
+    modules: journal.entries.map((entry) => entry.installed)
+  });
+  for (const [index, entry] of [...journal.entries.entries()].reverse()) {
+    const destination = resolveInside(
+      workspace.root,
+      entry.installed.directory
+    );
+    await safeParents(workspace, destination);
+    const backup = join6(transaction, `backup-${index}`);
+    const moved = !await exists2(join6(transaction, `stage-${index}`));
+    if (moved && await exists2(destination)) {
+      const hashes = await directoryHashes(destination);
+      if (equalHashes(hashes, entry.installed.files))
+        await rm(destination, { recursive: true });
+      else
+        distributionAssert(
+          entry.previous && equalHashes(hashes, entry.previous.files) && !await exists2(backup),
+          "MODULE_RECOVERY_CONFLICT",
+          `Recovery preserved modified files in ${entry.installed.directory}.`
+        );
+    }
+    if (await exists2(backup)) {
+      distributionAssert(
+        !await exists2(destination),
+        "MODULE_RECOVERY_CONFLICT",
+        "Recovery destination is occupied."
+      );
+      await safeParents(workspace, backup);
+      await rename(backup, destination);
+    }
+  }
+  const lockPath = join6(workspace.root, LOCK);
+  await safeParents(workspace, lockPath);
+  const current = await exists2(lockPath) ? await readFile8(lockPath, "utf8") : null;
+  distributionAssert(
+    current === journal.previous || current === journal.next,
+    "MODULE_RECOVERY_CONFLICT",
+    "Lockfile changed during installation; recovery preserved it."
+  );
+  if (journal.previous === null) await rm(lockPath, { force: true });
+  else await writeFile(lockPath, journal.previous);
+}
+async function installModule(workspace, options) {
+  const transaction = join6(workspace.root, TRANSACTION);
+  await safeParents(workspace, transaction);
+  distributionAssert(
+    !await exists2(transaction),
+    "MODULE_INSTALL_BUSY",
+    "A module installation is active or interrupted. Use module recover after its process exits."
+  );
+  const source = await loadModuleCatalog(options.registry, options.fetcher);
+  const snapshot = await readLock(workspace);
+  const manifests = [];
+  for (const root of moduleRoots(workspace)) await safeParents(workspace, root);
+  const files = await findModuleFiles(workspace);
+  for (const file of files)
+    manifests.push(JSON.parse(await readFile8(file, "utf8")));
+  const id = options.target.split("@")[0];
+  const previous = snapshot.lock.modules.find((entry) => entry.id === id);
+  distributionAssert(
+    previous || !manifests.some((manifest) => manifest.id === id),
+    "MODULE_NOT_MANAGED",
+    `Module ${id} already exists as unmanaged workspace/package source.`
+  );
+  if (options.update) {
+    distributionAssert(
+      previous,
+      "MODULE_NOT_MANAGED",
+      `Module ${id} is not managed by this installer.`
+    );
+    await assertUnmodified(workspace, previous);
+  }
+  const retained = options.update ? manifests.filter((manifest) => manifest.id !== id) : manifests;
+  const releases = resolveModuleReleases(
+    source.catalog,
+    options.target,
+    retained
+  );
+  if (options.update) {
+    const next = releases.find((release) => release.manifest.id === id);
+    distributionAssert(
+      next && compareModuleVersions(next.manifest.version, previous.version) <= 0,
+      "MODULE_DOWNGRADE_FORBIDDEN",
+      "Module downgrades are not supported."
+    );
+  }
+  const registry = createModuleRegistry(
+    [...retained, ...releases.map((release) => release.manifest)].map(
+      (manifest) => ({ manifest })
+    )
+  );
+  void registry;
+  if (!releases.length) {
+    if (previous) await assertUnmodified(workspace, previous);
+    return { applied: false, modules: [], activationRequired: false };
+  }
+  const entries = [];
+  let totalBytes = 0;
+  for (const release of releases) {
+    const bytes = await readRelease(source, release, options.fetcher);
+    totalBytes += bytes.length;
+    distributionAssert(
+      totalBytes <= 96 * 1024 * 1024,
+      "MODULE_INSTALL_LIMIT",
+      "The dependency closure exceeds the installation size limit."
+    );
+    distributionAssert(
+      hashBytes(bytes) === release.sha256,
+      "MODULE_ARTIFACT_DIGEST",
+      `Artifact digest mismatch for ${release.manifest.id}.`
+    );
+    const artifact = validateModuleArtifact(JSON.parse(bytes.toString("utf8")));
+    distributionAssert(
+      JSON.stringify(artifact.manifest) === JSON.stringify(release.manifest),
+      "MODULE_ARTIFACT_IDENTITY",
+      "Catalog and artifact manifest differ."
+    );
+    const old = snapshot.lock.modules.find((entry) => entry.id === release.manifest.id) ?? null;
+    const destination = old ? resolveInside(workspace.root, old.directory) : join6(
+      moduleRoots(workspace)[0],
+      release.manifest.package.replace("@flowdular/module-", "")
+    );
+    await safeParents(workspace, destination);
+    if (old) {
+      distributionAssert(
+        options.update && old.id === id,
+        "MODULE_ALREADY_INSTALLED",
+        `Module ${old.id} is already managed.`
+      );
+      await assertUnmodified(workspace, old);
+    } else
+      distributionAssert(
+        !await exists2(destination),
+        "MODULE_DESTINATION_EXISTS",
+        `Destination exists: ${relative5(workspace.root, destination)}`
+      );
+    const hashes = Object.fromEntries(
+      artifact.files.map((file) => [file.path, file.sha256])
+    );
+    if (old) {
+      for (const [path, hash] of Object.entries(old.files))
+        if (path.startsWith("migrations/"))
+          distributionAssert(
+            hashes[path] === hash,
+            "MODULE_MIGRATION_CHANGED",
+            `Update changes historical migration ${path}.`
+          );
+    }
+    entries.push({
+      release,
+      artifact,
+      previous: old,
+      installed: {
+        id: release.manifest.id,
+        version: release.manifest.version,
+        directory: relative5(workspace.root, destination),
+        artifact: release.artifact,
+        sha256: release.sha256,
+        sourceCommit: release.sourceCommit,
+        files: hashes
+      }
+    });
+  }
+  const nextLock = {
+    schemaVersion: 1,
+    modules: [
+      ...snapshot.lock.modules.filter(
+        (entry) => !entries.some((next) => next.installed.id === entry.id)
+      ),
+      ...entries.map((entry) => entry.installed)
+    ].sort((a, b) => a.id.localeCompare(b.id))
+  };
+  validateLock(workspace, nextLock);
+  if (!options.apply)
+    return {
+      applied: false,
+      modules: entries.map((entry) => entry.installed),
+      activationRequired: true
+    };
+  await mkdir(transaction);
+  const journal = {
+    schemaVersion: 1,
+    pid: process.pid,
+    previous: snapshot.raw,
+    next: JSON.stringify(nextLock, null, "	") + "\n",
+    entries: entries.map((entry) => ({
+      installed: entry.installed,
+      previous: entry.previous
+    }))
+  };
+  let journalWritten = false;
+  try {
+    await writeFile(
+      join6(transaction, "owner.json"),
+      JSON.stringify({ schemaVersion: 1, pid: process.pid })
+    );
+    for (const [index, entry] of entries.entries()) {
+      const stage = join6(transaction, `stage-${index}`);
+      await mkdir(stage);
+      for (const file of entry.artifact.files) {
+        const path = join6(stage, file.path);
+        await mkdir(dirname6(path), { recursive: true });
+        await writeFile(path, Buffer.from(file.content, "base64"), {
+          flag: "wx"
+        });
+      }
+      const issues = await moduleLayoutIssues(stage, entry.artifact.manifest);
+      distributionAssert(
+        !issues.some((issue2) => issue2.severity === "error"),
+        "MODULE_LAYOUT_INVALID",
+        `Invalid module layout: ${issues.map((issue2) => issue2.message).join("; ")}`
+      );
+    }
+    await writeFile(join6(transaction, "journal.tmp"), JSON.stringify(journal));
+    await rename(
+      join6(transaction, "journal.tmp"),
+      join6(transaction, "journal.json")
+    );
+    journalWritten = true;
+    distributionAssert(
+      (await readLock(workspace)).raw === snapshot.raw,
+      "MODULE_CONCURRENT_CHANGE",
+      "Module lock changed during planning."
+    );
+    for (const [index, entry] of entries.entries()) {
+      const destination = resolveInside(
+        workspace.root,
+        entry.installed.directory
+      );
+      await safeParents(workspace, destination);
+      if (entry.previous) {
+        await assertUnmodified(workspace, entry.previous);
+        await rename(destination, join6(transaction, `backup-${index}`));
+      } else
+        distributionAssert(
+          !await exists2(destination),
+          "MODULE_DESTINATION_EXISTS",
+          `Destination appeared during installation: ${entry.installed.directory}`
+        );
+      await mkdir(dirname6(destination), { recursive: true });
+      await rename(join6(transaction, `stage-${index}`), destination);
+    }
+    await writeFile(join6(transaction, "next-lock.json"), journal.next);
+    await rename(
+      join6(transaction, "next-lock.json"),
+      join6(workspace.root, LOCK)
+    );
+  } catch (error) {
+    if (journalWritten) await rollback(workspace, journal);
+    await rm(transaction, { recursive: true });
+    throw error;
+  }
+  await rm(transaction, { recursive: true });
+  return {
+    applied: true,
+    modules: entries.map((entry) => entry.installed),
+    activationRequired: true
+  };
+}
+// src/module-sync.ts
+import { spawnSync } from "node:child_process";
+import { access as access3, mkdir as mkdir2, readFile as readFile9, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname7, join as join8 } from "node:path";
+// src/format.ts
+import { createRequire as createRequire3 } from "node:module";
+import { join as join7 } from "node:path";
+import { pathToFileURL } from "node:url";
+var DEFAULT_OPTIONS = {
+  useTabs: true,
+  singleQuote: true,
+  trailingComma: "all"
+};
+var TSRX_PLUGIN = "@tsrx/prettier-plugin";
+function resolveFrom(workspaceRoot, specifier) {
+  for (const base of [join7(workspaceRoot, "package.json"), import.meta.url]) {
+    try {
+      return createRequire3(base).resolve(specifier);
+    } catch {
+    }
+  }
+  throw new Error(`Cannot resolve ${specifier} from ${workspaceRoot}.`);
+}
+async function importModule(path) {
+  const imported = await import(pathToFileURL(path).href);
+  return imported.default ?? imported;
+}
+async function loadWorkspaceFormatter(workspaceRoot) {
+  let prettier;
+  let plugins;
+  try {
+    prettier = await importModule(
+      resolveFrom(workspaceRoot, "prettier")
+    );
+    plugins = [
+      await importModule(
+        resolveFrom(workspaceRoot, TSRX_PLUGIN)
+      )
+    ];
+  } catch {
+    return null;
+  }
+  const configured = await prettier.resolveConfig(
+    join7(workspaceRoot, "package.json"),
+    { editorconfig: false }
+  );
+  const { plugins: _ignored, ...options } = configured ?? DEFAULT_OPTIONS;
+  return {
+    async format(path, source) {
+      const info = await prettier.getFileInfo(path, { plugins });
+      if (!info.inferredParser) return source;
+      return prettier.format(source, { ...options, plugins, filepath: path });
+    }
+  };
+}
+// src/module-sync.ts
+async function writeProjectConfig(workspace, config) {
+  const raw = JSON.stringify(config, null, "	") + "\n";
+  const formatter = await loadWorkspaceFormatter(workspace.root);
+  const output = formatter ? await formatter.format(workspace.configPath, raw) : raw;
+  await writeFile2(workspace.configPath, output);
+}
+var GENERATED_FILES = {
+  server: "platform/src/generated/modules.server.ts",
+  client: "platform/src/generated/modules.client.ts"
+};
+var GENERATED_HEADER = '/* GENERATED by "flowdular module sync". Do not edit by hand; run\n   "pnpm flowdular module sync --apply" after enabling or disabling modules. */\n';
+function identifier(id) {
+  return id.replace(/[^a-zA-Z0-9]+/g, "_");
+}
+function platformImport(id, pkg, entry) {
+  return `import { ${entry} as ${identifier(id)} } from '${pkg}/platform';`;
+}
+function clientImport(id, pkg) {
+  return `import { createClientContribution as ${identifier(id)} } from '${pkg}/client';`;
+}
+function generateServerComposition(modules, sdk = false, mounts = [], applicationPath = "/app") {
+  const server = modules.filter((module) => module.server);
+  const typeImport = `import type {
+	PlatformServerComposition,
+	PlatformServerContext,
+} from '${sdk ? "@flowdular/sdk/modules/auth" : "@flowdular/module-auth"}/server';
+`;
+  if (server.length === 0) {
+    return GENERATED_HEADER + typeImport + "\nexport function composeModuleServer(\n	_context: PlatformServerContext,\n): readonly PlatformServerComposition[] {\n	return [];\n}\n\nexport const moduleWebMounts = " + JSON.stringify(mounts) + " as const;\nexport const applicationBasePath = " + JSON.stringify(applicationPath) + ";\n";
+  }
+  const imports = server.map(
+    (module) => platformImport(module.id, module.package, "createServerComposition")
+  ).join("\n");
+  const calls = server.map(
+    (module) => `		{ ...${identifier(module.id)}({
+			...context,
+			agentDefinitions: context.agentDefinitions.forModule('${module.id}'),
+		}), moduleId: '${module.id}' },`
+  ).join("\n");
+  return GENERATED_HEADER + typeImport + imports + "\n\nexport function composeModuleServer(\n	context: PlatformServerContext,\n): readonly PlatformServerComposition[] {\n	return [\n" + calls + "\n	];\n}\n\nexport const moduleWebMounts = " + JSON.stringify(mounts) + " as const;\nexport const applicationBasePath = " + JSON.stringify(applicationPath) + ";\n";
+}
+function generateClientComposition(modules, sdk = false, applicationPath = "/app") {
+  const client = modules.filter((module) => module.client);
+  const typeImport = `import type {
+	ModuleClientContext,
+	ModuleClientContribution,
+} from '${sdk ? "@flowdular/sdk/client" : "@flowdular/client"}';
+`;
+  if (client.length === 0) {
+    return GENERATED_HEADER + "export const applicationBasePath = " + JSON.stringify(applicationPath) + ";\n" + typeImport + "\nexport function createModuleClientContributions(\n	_context: ModuleClientContext,\n): readonly ModuleClientContribution[] {\n	return [];\n}\n";
+  }
+  const imports = client.map((module) => clientImport(module.id, module.package)).join("\n");
+  const calls = client.map((module) => `		${identifier(module.id)}(context),`).join("\n");
+  return GENERATED_HEADER + "export const applicationBasePath = " + JSON.stringify(applicationPath) + ";\n" + typeImport + imports + "\n\nexport function createModuleClientContributions(\n	context: ModuleClientContext,\n): readonly ModuleClientContribution[] {\n	return [\n" + calls + "\n	];\n}\n";
+}
+async function loadManifests(workspace) {
+  const files = await findModuleFiles(workspace);
+  const bundled = await sdkModules(workspace);
+  const descriptors = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const manifest = JSON.parse(
+      await readFile9(file, "utf8")
+    );
+    if (!validators.module(manifest))
+      throw new Error(`Invalid module manifest: ${file}`);
+    assertModuleCompatibility(manifest);
+    if (descriptors.has(manifest.id)) {
+      throw new Error(`Module id is registered more than once: ${manifest.id}`);
+    }
+    descriptors.set(manifest.id, {
+      manifest,
+      id: manifest.id,
+      package: bundled.get(file) ?? manifest.package,
+      server: manifest.platform?.server === true,
+      client: manifest.platform?.client === true,
+      dependencies: manifest.dependencies.map((dependency) => dependency.id)
+    });
+  }
+  return descriptors;
+}
+function moduleOrder(manifests, roots, includeDependencies) {
+  const requested = new Set(roots);
+  const visiting = [];
+  const visited = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (id, requiredBy) => {
+    if (visited.has(id)) return;
+    const cycleStart = visiting.indexOf(id);
+    if (cycleStart !== -1) {
+      const cycle = [...visiting.slice(cycleStart), id];
+      throw new Error(`Dependency cycle detected: ${cycle.join(" -> ")}.`);
+    }
+    const current = manifests.get(id);
+    if (!current) {
+      if (requiredBy) {
+        throw new Error(
+          `Module "${requiredBy}" requires missing module "${id}".`
+        );
+      }
+      throw new Error(`Enabled module is not registered: ${id}`);
+    }
+    visiting.push(id);
+    for (const dependency of [...current.dependencies].sort(
+      (left, right) => left.localeCompare(right)
+    )) {
+      if (!includeDependencies && !requested.has(dependency)) {
+        throw new Error(
+          `Enabled module "${id}" requires disabled module "${dependency}". Enable the dependency first.`
+        );
+      }
+      const constraint = current.manifest?.dependencies.find(
+        (entry) => entry.id === dependency
+      );
+      const version = manifests.get(dependency)?.manifest?.version;
+      if (constraint && version)
+        assertModuleDependency(id, constraint, version);
+      visit(dependency, id);
+    }
+    visiting.pop();
+    visited.add(id);
+    ordered.push(current);
+  };
+  for (const id of [...requested].sort(
+    (left, right) => left.localeCompare(right)
+  )) {
+    visit(id);
+  }
+  return ordered;
+}
+function enabledModules(workspace) {
+  return workspace.config.modules?.enabled ?? [];
+}
+async function resolveEnabled(workspace, enabled) {
+  const manifests = await loadManifests(workspace);
+  return moduleOrder(manifests, enabled, false);
+}
+function equalIds(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+async function takeSnapshots(paths) {
+  return Promise.all(
+    paths.map(async (path) => {
+      try {
+        return { path, content: await readFile9(path, "utf8") };
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return { path, content: void 0 };
+        }
+        throw error;
+      }
+    })
+  );
+}
+async function restoreSnapshots(snapshots) {
+  for (const snapshot of [...snapshots].reverse()) {
+    if (snapshot.content === void 0) {
+      await rm2(snapshot.path, { force: true });
+      continue;
+    }
+    await mkdir2(dirname7(snapshot.path), { recursive: true });
+    await writeFile2(snapshot.path, snapshot.content);
+  }
+}
+async function syncPlatformModules(workspace, apply, enabledOverride) {
+  if (workspace.config.web !== void 0 && !validators.web(workspace.config.web))
+    throw new Error("Invalid web mount configuration in flowdular.json.");
+  if (workspace.config.application !== void 0 && !validators.application(workspace.config.application)) throw new Error("Invalid application path in flowdular.json.");
+  const applicationPath = workspace.config.application?.path ?? "/app";
+  const enabled = enabledOverride ?? enabledModules(workspace);
+  const sdk = (await sdkModules(workspace)).size > 0;
+  const modules = await resolveEnabled(workspace, enabled);
+  const formatter = await loadWorkspaceFormatter(workspace.root);
+  const targets = await Promise.all(
+    [
+      {
+        path: GENERATED_FILES.server,
+        content: generateServerComposition(
+          modules,
+          sdk,
+          workspace.config.web?.mounts ?? []
+        )
+      },
+      {
+        path: GENERATED_FILES.client,
+        content: generateClientComposition(modules, sdk, applicationPath)
+      }
+    ].map(async (target) => {
+      const absolute = join8(workspace.root, target.path);
+      return {
+        ...target,
+        content: formatter ? await formatter.format(absolute, target.content) : target.content
+      };
+    })
+  );
+  const files = [];
+  for (const target of targets) {
+    const absolute = join8(workspace.root, target.path);
+    let current = "";
+    try {
+      current = await readFile9(absolute, "utf8");
+    } catch {
+    }
+    const changed = current !== target.content;
+    if (apply && changed) {
+      await mkdir2(dirname7(absolute), { recursive: true });
+      await writeFile2(absolute, target.content);
+    }
+    files.push({ path: target.path, changed });
+  }
+  return {
+    modules: modules.map((module) => module.id),
+    files,
+    applied: apply
+  };
+}
+async function enableModule(workspace, id, apply) {
+  const manifests = await loadManifests(workspace);
+  const descriptor = manifests.get(id);
+  if (!descriptor) {
+    throw new Error(`Unknown module id: ${id}`);
+  }
+  const current = enabledModules(workspace);
+  const alreadyEnabled = current.includes(id);
+  const modules = moduleOrder(manifests, [...current, id], true);
+  const enabled = modules.map((module) => module.id);
+  const currentSet = new Set(current);
+  const newlyEnabled = enabled.filter((moduleId) => !currentSet.has(moduleId));
+  const configChanged = !equalIds(current, enabled);
+  const platformPackagePath = join8(workspace.root, "platform/package.json");
+  const platformPackage = JSON.parse(
+    await readFile9(platformPackagePath, "utf8")
+  );
+  const dependencies = platformPackage.dependencies ?? {};
+  const platformDependenciesAdded = modules.map((module) => npmPackage(module.package)).filter((packageName) => !(packageName in dependencies)).sort((left, right) => left.localeCompare(right));
+  const platformDependencyAdded = platformDependenciesAdded.length > 0;
+  for (const packageName of platformDependenciesAdded) {
+    dependencies[packageName] = packageName === "@flowdular/sdk" ? SDK_VERSION : "workspace:*";
+  }
+  if (platformDependencyAdded) {
+    platformPackage.dependencies = Object.fromEntries(
+      Object.entries(dependencies).sort(
+        ([left], [right]) => left.localeCompare(right)
+      )
+    );
+  }
+  const linked = async (module) => {
+    try {
+      await access3(
+        join8(
+          workspace.root,
+          "platform/node_modules",
+          npmPackage(module.package)
+        )
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const allLinked = async () => (await Promise.all(modules.map((module) => linked(module)))).every(Boolean);
+  let installed = await allLinked();
+  let installRan = false;
+  let sync;
+  if (apply) {
+    const snapshots = await takeSnapshots([
+      workspace.configPath,
+      join8(workspace.root, "pnpm-lock.yaml"),
+      platformPackagePath,
+      ...Object.values(GENERATED_FILES).map(
+        (path) => join8(workspace.root, path)
+      )
+    ]);
+    try {
+      if (configChanged) {
+        const config = JSON.parse(
+          await readFile9(workspace.configPath, "utf8")
+        );
+        const configModules = config.modules ?? {};
+        configModules.enabled = enabled;
+        config.modules = configModules;
+        await writeProjectConfig(workspace, config);
+      }
+      if (platformDependencyAdded) {
+        await writeFile2(
+          platformPackagePath,
+          JSON.stringify(platformPackage, null, "	") + "\n"
+        );
+      }
+      if (!installed) {
+        installRan = true;
+        const install = spawnSync(
+          "pnpm",
+          ["install", "--ignore-scripts", "--no-frozen-lockfile"],
+          {
+            cwd: workspace.root,
+            stdio: "pipe",
+            encoding: "utf8"
+          }
+        );
+        if (install.error || install.status !== 0) {
+          const output = `${install.stdout ?? ""}${install.stderr ?? ""}`.trim().split("\n").slice(-20).join("\n");
+          throw new Error(
+            `pnpm install failed while linking the module package${install.error ? ` (${install.error.message})` : ` (exit ${install.status})`}. Run it manually and retry.${output ? `
+${output}` : ""}`
+          );
+        }
+        installed = await allLinked();
+      }
+      sync = await syncPlatformModules(workspace, true, enabled);
+    } catch (error) {
+      await restoreSnapshots(snapshots);
+      throw error;
+    }
+  } else {
+    sync = await syncPlatformModules(workspace, false, enabled);
+  }
+  return {
+    ...sync,
+    enabled,
+    newlyEnabled,
+    alreadyEnabled,
+    platformDependencyAdded,
+    platformDependenciesAdded,
+    installRan,
+    installed
+  };
+}
+export {
+  enableModule,
+  hashBytes,
+  installModule,
+  loadModuleCatalog,
+  packModule,
+  readModuleSource,
+  resolveModuleReleases,
+  sourceDigest,
+  syncPlatformModules,
+  validateInstalledModules,
+  validateModuleArtifact
+};