@fragment-dev/cli 2026.10.1-8 → 2026.10.1

package/dist/chunk-NT74GT6W.js

@@ -1,1287 +0,0 @@
-import {
-  validateSchemaStructure
-} from "./chunk-IQIFAKDJ.js";
-import {
-  ChartOfAccounts,
-  MIN_SCHEMA_LEDGER_ENTRY_DISABLED_DURATION_SECONDS,
-  N,
-  Schema,
-  areExpressionsEqual,
-  evaluateExpressionWithVars,
-  getAccountStatus,
-  parseWithError,
-  stringify,
-  z
-} from "./chunk-PHWV3NOP.js";
-import {
-  PaymentAccountingEventKey,
-  VALID_LEDGER_ACCOUNT_STATUS_TRANSITIONS,
-  getSchemaObjectParameters
-} from "./chunk-23KWDUJZ.js";
-import {
-  BadRequestError,
-  InternalError,
-  assert_default,
-  isEqual_default
-} from "./chunk-XJ2TNWI7.js";
-import {
-  getParsedSchemaString,
-  parseJSON
-} from "./chunk-QZNZYG2G.js";
-import {
-  __commonJS,
-  __require,
-  __toESM,
-  init_cjs_shims
-} from "./chunk-7GH3YGSC.js";
-
-// ../../node_modules/object-hash/index.js
-var require_object_hash = __commonJS({
-  "../../node_modules/object-hash/index.js"(exports, module) {
-    "use strict";
-    init_cjs_shims();
-    var crypto = __require("crypto");
-    exports = module.exports = objectHash;
-    function objectHash(object, options) {
-      options = applyDefaults(object, options);
-      return hash2(object, options);
-    }
-    exports.sha1 = function(object) {
-      return objectHash(object);
-    };
-    exports.keys = function(object) {
-      return objectHash(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
-    };
-    exports.MD5 = function(object) {
-      return objectHash(object, { algorithm: "md5", encoding: "hex" });
-    };
-    exports.keysMD5 = function(object) {
-      return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
-    };
-    var hashes = crypto.getHashes ? crypto.getHashes().slice() : ["sha1", "md5"];
-    hashes.push("passthrough");
-    var encodings = ["buffer", "hex", "binary", "base64"];
-    function applyDefaults(object, sourceOptions) {
-      sourceOptions = sourceOptions || {};
-      var options = {};
-      options.algorithm = sourceOptions.algorithm || "sha1";
-      options.encoding = sourceOptions.encoding || "hex";
-      options.excludeValues = sourceOptions.excludeValues ? true : false;
-      options.algorithm = options.algorithm.toLowerCase();
-      options.encoding = options.encoding.toLowerCase();
-      options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
-      options.respectType = sourceOptions.respectType === false ? false : true;
-      options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
-      options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
-      options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
-      options.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
-      options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
-      options.replacer = sourceOptions.replacer || void 0;
-      options.excludeKeys = sourceOptions.excludeKeys || void 0;
-      if (typeof object === "undefined") {
-        throw new Error("Object argument required.");
-      }
-      for (var i = 0; i < hashes.length; ++i) {
-        if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
-          options.algorithm = hashes[i];
-        }
-      }
-      if (hashes.indexOf(options.algorithm) === -1) {
-        throw new Error('Algorithm "' + options.algorithm + '"  not supported. supported values: ' + hashes.join(", "));
-      }
-      if (encodings.indexOf(options.encoding) === -1 && options.algorithm !== "passthrough") {
-        throw new Error('Encoding "' + options.encoding + '"  not supported. supported values: ' + encodings.join(", "));
-      }
-      return options;
-    }
-    function isNativeFunction(f) {
-      if (typeof f !== "function") {
-        return false;
-      }
-      var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
-      return exp.exec(Function.prototype.toString.call(f)) != null;
-    }
-    function hash2(object, options) {
-      var hashingStream;
-      if (options.algorithm !== "passthrough") {
-        hashingStream = crypto.createHash(options.algorithm);
-      } else {
-        hashingStream = new PassThrough();
-      }
-      if (typeof hashingStream.write === "undefined") {
-        hashingStream.write = hashingStream.update;
-        hashingStream.end = hashingStream.update;
-      }
-      var hasher = typeHasher(options, hashingStream);
-      hasher.dispatch(object);
-      if (!hashingStream.update) {
-        hashingStream.end("");
-      }
-      if (hashingStream.digest) {
-        return hashingStream.digest(options.encoding === "buffer" ? void 0 : options.encoding);
-      }
-      var buf = hashingStream.read();
-      if (options.encoding === "buffer") {
-        return buf;
-      }
-      return buf.toString(options.encoding);
-    }
-    exports.writeToStream = function(object, options, stream) {
-      if (typeof stream === "undefined") {
-        stream = options;
-        options = {};
-      }
-      options = applyDefaults(object, options);
-      return typeHasher(options, stream).dispatch(object);
-    };
-    function typeHasher(options, writeTo, context) {
-      context = context || [];
-      var write = function(str) {
-        if (writeTo.update) {
-          return writeTo.update(str, "utf8");
-        } else {
-          return writeTo.write(str, "utf8");
-        }
-      };
-      return {
-        dispatch: function(value) {
-          if (options.replacer) {
-            value = options.replacer(value);
-          }
-          var type = typeof value;
-          if (value === null) {
-            type = "null";
-          }
-          return this["_" + type](value);
-        },
-        _object: function(object) {
-          var pattern = /\[object (.*)\]/i;
-          var objString = Object.prototype.toString.call(object);
-          var objType = pattern.exec(objString);
-          if (!objType) {
-            objType = "unknown:[" + objString + "]";
-          } else {
-            objType = objType[1];
-          }
-          objType = objType.toLowerCase();
-          var objectNumber = null;
-          if ((objectNumber = context.indexOf(object)) >= 0) {
-            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
-          } else {
-            context.push(object);
-          }
-          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
-            write("buffer:");
-            return write(object);
-          }
-          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
-            if (this["_" + objType]) {
-              this["_" + objType](object);
-            } else if (options.ignoreUnknown) {
-              return write("[" + objType + "]");
-            } else {
-              throw new Error('Unknown object type "' + objType + '"');
-            }
-          } else {
-            var keys = Object.keys(object);
-            if (options.unorderedObjects) {
-              keys = keys.sort();
-            }
-            if (options.respectType !== false && !isNativeFunction(object)) {
-              keys.splice(0, 0, "prototype", "__proto__", "constructor");
-            }
-            if (options.excludeKeys) {
-              keys = keys.filter(function(key) {
-                return !options.excludeKeys(key);
-              });
-            }
-            write("object:" + keys.length + ":");
-            var self = this;
-            return keys.forEach(function(key) {
-              self.dispatch(key);
-              write(":");
-              if (!options.excludeValues) {
-                self.dispatch(object[key]);
-              }
-              write(",");
-            });
-          }
-        },
-        _array: function(arr, unordered) {
-          unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
-          var self = this;
-          write("array:" + arr.length + ":");
-          if (!unordered || arr.length <= 1) {
-            return arr.forEach(function(entry) {
-              return self.dispatch(entry);
-            });
-          }
-          var contextAdditions = [];
-          var entries = arr.map(function(entry) {
-            var strm = new PassThrough();
-            var localContext = context.slice();
-            var hasher = typeHasher(options, strm, localContext);
-            hasher.dispatch(entry);
-            contextAdditions = contextAdditions.concat(localContext.slice(context.length));
-            return strm.read().toString();
-          });
-          context = context.concat(contextAdditions);
-          entries.sort();
-          return this._array(entries, false);
-        },
-        _date: function(date) {
-          return write("date:" + date.toJSON());
-        },
-        _symbol: function(sym) {
-          return write("symbol:" + sym.toString());
-        },
-        _error: function(err) {
-          return write("error:" + err.toString());
-        },
-        _boolean: function(bool) {
-          return write("bool:" + bool.toString());
-        },
-        _string: function(string) {
-          write("string:" + string.length + ":");
-          write(string.toString());
-        },
-        _function: function(fn) {
-          write("fn:");
-          if (isNativeFunction(fn)) {
-            this.dispatch("[native]");
-          } else {
-            this.dispatch(fn.toString());
-          }
-          if (options.respectFunctionNames !== false) {
-            this.dispatch("function-name:" + String(fn.name));
-          }
-          if (options.respectFunctionProperties) {
-            this._object(fn);
-          }
-        },
-        _number: function(number) {
-          return write("number:" + number.toString());
-        },
-        _xml: function(xml) {
-          return write("xml:" + xml.toString());
-        },
-        _null: function() {
-          return write("Null");
-        },
-        _undefined: function() {
-          return write("Undefined");
-        },
-        _regexp: function(regex) {
-          return write("regex:" + regex.toString());
-        },
-        _uint8array: function(arr) {
-          write("uint8array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint8clampedarray: function(arr) {
-          write("uint8clampedarray:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int8array: function(arr) {
-          write("int8array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint16array: function(arr) {
-          write("uint16array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int16array: function(arr) {
-          write("int16array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint32array: function(arr) {
-          write("uint32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int32array: function(arr) {
-          write("int32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _float32array: function(arr) {
-          write("float32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _float64array: function(arr) {
-          write("float64array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _arraybuffer: function(arr) {
-          write("arraybuffer:");
-          return this.dispatch(new Uint8Array(arr));
-        },
-        _url: function(url) {
-          return write("url:" + url.toString(), "utf8");
-        },
-        _map: function(map) {
-          write("map:");
-          var arr = Array.from(map);
-          return this._array(arr, options.unorderedSets !== false);
-        },
-        _set: function(set) {
-          write("set:");
-          var arr = Array.from(set);
-          return this._array(arr, options.unorderedSets !== false);
-        },
-        _file: function(file) {
-          write("file:");
-          return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
-        },
-        _blob: function() {
-          if (options.ignoreUnknown) {
-            return write("[blob]");
-          }
-          throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
-        },
-        _domwindow: function() {
-          return write("domwindow");
-        },
-        _bigint: function(number) {
-          return write("bigint:" + number.toString());
-        },
-        /* Node.js standard native objects */
-        _process: function() {
-          return write("process");
-        },
-        _timer: function() {
-          return write("timer");
-        },
-        _pipe: function() {
-          return write("pipe");
-        },
-        _tcp: function() {
-          return write("tcp");
-        },
-        _udp: function() {
-          return write("udp");
-        },
-        _tty: function() {
-          return write("tty");
-        },
-        _statwatcher: function() {
-          return write("statwatcher");
-        },
-        _securecontext: function() {
-          return write("securecontext");
-        },
-        _connection: function() {
-          return write("connection");
-        },
-        _zlib: function() {
-          return write("zlib");
-        },
-        _context: function() {
-          return write("context");
-        },
-        _nodescript: function() {
-          return write("nodescript");
-        },
-        _httpparser: function() {
-          return write("httpparser");
-        },
-        _dataview: function() {
-          return write("dataview");
-        },
-        _signal: function() {
-          return write("signal");
-        },
-        _fsevent: function() {
-          return write("fsevent");
-        },
-        _tlswrap: function() {
-          return write("tlswrap");
-        }
-      };
-    }
-    function PassThrough() {
-      return {
-        buf: "",
-        write: function(b) {
-          this.buf += b;
-        },
-        end: function(b) {
-          this.buf += b;
-        },
-        read: function() {
-          return this.buf;
-        }
-      };
-    }
-  }
-});
-
-// src/utils/schemaBackCompat.ts
-init_cjs_shims();
-
-// ../../libs/schema-validation/utils/backcompat/evaluateDeployBackCompat.ts
-init_cjs_shims();
-
-// ../../libs/schema-validation/utils/backcompat/verifySchemaBackCompat.ts
-init_cjs_shims();
-
-// ../../libs/schema-validation/utils/validateSchema.ts
-init_cjs_shims();
-var validateSchema = (schema) => {
-  const validatedSchema = parseWithError(Schema, schema, BadRequestError, {
-    message: "Invalid schema provided"
-  });
-  return validatedSchema;
-};
-
-// ../../libs/schema-validation/utils/backcompat/entries.ts
-init_cjs_shims();
-var import_object_hash = __toESM(require_object_hash(), 1);
-
-// ../../libs/comparison-utils/index.ts
-init_cjs_shims();
-var createComparator = (paths) => {
-  return (t1, t2) => paths.filter((path) => {
-    const left = path.serializer(t1);
-    const right = path.serializer(t2);
-    const comparisonFn = path.comparisonFn ?? isEqual_default;
-    return !comparisonFn(left, right);
-  }).map(
-    (path) => `Found a mismatch at ${path.name}: ${stringify(
-      path.serializer(t1)
-    )} !== ${stringify(path.serializer(t2))}`
-  );
-};
-
-// ../../libs/schema-validation/utils/backcompat/entries.ts
-var areSetsEqual = (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
-var isFieldCheck = (value) => typeof value.serializer === "function";
-var flattenChecks = (checks) => isFieldCheck(checks) ? [checks] : Object.values(checks);
-var verifyAmountBackCompat = (oldLine, newLine, basePath) => {
-  if (!oldLine.amount?.trim()) {
-    return newLine.amount?.trim() ? [{ path: [...basePath, "amount"], message: `Amount added to line.` }] : [];
-  }
-  if (!newLine.amount?.trim()) {
-    return [
-      { path: [...basePath, "amount"], message: `Amount removed from line.` }
-    ];
-  }
-  try {
-    const oldAmountExpression = evaluateExpressionWithVars(oldLine.amount);
-    const newAmountExpression = evaluateExpressionWithVars(newLine.amount);
-    return areExpressionsEqual(oldAmountExpression, newAmountExpression) ? [] : [
-      {
-        path: [...basePath, "amount"],
-        message: `Amount changed from '${oldLine.amount}' to '${newLine.amount}'.`
-      }
-    ];
-  } catch (err) {
-    return [];
-  }
-};
-var verifyLineTagsBackCompat = (oldLine, newLine, basePath) => {
-  const oldTags = new Set((oldLine.tags ?? []).map((tag) => (0, import_object_hash.default)(tag)));
-  const newTags = new Set((newLine.tags ?? []).map((tag) => (0, import_object_hash.default)(tag)));
-  return areSetsEqual(oldTags, newTags) ? [] : [{ path: [...basePath, "tags"], message: `Tags changed on line.` }];
-};
-var linePolicies = {
-  amount: { kind: "custom", check: verifyAmountBackCompat },
-  key: {
-    kind: "compare",
-    checks: { serializer: (line) => line.key, name: "key" }
-  },
-  account: {
-    kind: "compare",
-    checks: {
-      path: { serializer: (line) => line.account?.path, name: "accountPath" }
-    }
-  },
-  currency: {
-    kind: "compare",
-    checks: {
-      code: {
-        serializer: (line) => line.currency?.code,
-        name: "currency.code"
-      },
-      customCurrencyId: {
-        serializer: (line) => line.currency?.customCurrencyId,
-        name: "currency.customCurrencyId"
-      }
-    }
-  },
-  tx: {
-    kind: "compare",
-    checks: {
-      id: { serializer: (line) => line.tx?.id, name: "tx.id" },
-      externalId: {
-        serializer: (line) => line.tx?.externalId,
-        name: "tx.externalId"
-      }
-    }
-  },
-  repeated: {
-    kind: "compare",
-    checks: {
-      key: { serializer: (line) => line.repeated?.key, name: "repeated.key" }
-    }
-  },
-  tags: { kind: "custom", check: verifyLineTagsBackCompat },
-  description: {
-    kind: "ignored",
-    reason: "Not part of the posted line; changing it does not affect entries."
-  }
-};
-var lineCheckers = Object.values(linePolicies).map(
-  (policy) => z(policy).returnType().with({ kind: "ignored" }, () => () => []).with({ kind: "compare" }, ({ checks }) => {
-    const comparator = createComparator(
-      flattenChecks(checks)
-    );
-    return (oldLine, newLine, basePath) => comparator(oldLine, newLine).map((message) => ({
-      path: [...basePath],
-      message
-    }));
-  }).with({ kind: "custom" }, ({ check }) => check).exhaustive()
-);
-var conditionComparator = createComparator([
-  { serializer: (condition) => condition.account?.path, name: "accountPath" },
-  {
-    serializer: (condition) => condition.currency?.code,
-    name: "currency.code"
-  },
-  {
-    serializer: (condition) => condition.currency?.customCurrencyId,
-    name: "currency.customCurrencyId"
-  },
-  {
-    serializer: (condition) => condition.repeated?.key,
-    name: "repeated.key"
-  }
-]);
-var verifyLineBackCompat = (oldLine, newLine, basePath) => lineCheckers.flatMap((checker) => checker(oldLine, newLine, basePath));
-var verifyConditionBackCompat = (oldCondition, newCondition, basePath) => {
-  const issues = [];
-  const compareComparatorValue = (oldValue, newValue, comparator, balanceType, conditionType) => {
-    const oldTrimmed = oldValue?.trim();
-    const newTrimmed = newValue?.trim();
-    if (!oldTrimmed && newTrimmed) {
-      issues.push({
-        path: [...basePath, conditionType, balanceType, comparator],
-        message: `${conditionType} ${balanceType} ${comparator} added.`
-      });
-    } else if (oldTrimmed && !newTrimmed) {
-      issues.push({
-        path: [...basePath, conditionType, balanceType, comparator],
-        message: `${conditionType} ${balanceType} ${comparator} removed.`
-      });
-    } else if (oldTrimmed && newTrimmed) {
-      try {
-        const oldExpression = evaluateExpressionWithVars(oldTrimmed);
-        const newExpression = evaluateExpressionWithVars(newTrimmed);
-        if (!areExpressionsEqual(oldExpression, newExpression)) {
-          issues.push({
-            path: [...basePath, conditionType, balanceType, comparator],
-            message: `${conditionType} ${balanceType} ${comparator} changed from '${oldTrimmed}' to '${newTrimmed}'.`
-          });
-        }
-      } catch (err) {
-      }
-    }
-  };
-  const compareConditionBalance = (oldBalance, newBalance, balanceType, conditionType) => {
-    compareComparatorValue(
-      oldBalance?.eq,
-      newBalance?.eq,
-      "eq",
-      balanceType,
-      conditionType
-    );
-    compareComparatorValue(
-      oldBalance?.lte,
-      newBalance?.lte,
-      "lte",
-      balanceType,
-      conditionType
-    );
-    compareComparatorValue(
-      oldBalance?.gte,
-      newBalance?.gte,
-      "gte",
-      balanceType,
-      conditionType
-    );
-  };
-  ["precondition", "postcondition"].forEach((conditionType) => {
-    const oldPart = oldCondition[conditionType];
-    const newPart = newCondition[conditionType];
-    const label = conditionType.charAt(0).toUpperCase() + conditionType.slice(1);
-    z([oldPart, newPart]).with([void 0, void 0], () => {
-    }).with([void 0, N.nonNullable], () => {
-      issues.push({
-        path: [...basePath, conditionType],
-        message: `${label} added.`
-      });
-    }).with([N.nonNullable, void 0], () => {
-      issues.push({
-        path: [...basePath, conditionType],
-        message: `${label} removed.`
-      });
-    }).with(
-      [N.nonNullable, N.nonNullable],
-      ([oldPartDefined, newPartDefined]) => {
-        const oldHasOwn = Boolean(oldPartDefined.ownBalance);
-        const oldHasTotal = Boolean(oldPartDefined.totalBalance);
-        const newHasOwn = Boolean(newPartDefined.ownBalance);
-        const newHasTotal = Boolean(newPartDefined.totalBalance);
-        const isOwnToTotal = oldHasOwn && !oldHasTotal && !newHasOwn && newHasTotal;
-        const isTotalToOwn = !oldHasOwn && oldHasTotal && newHasOwn && !newHasTotal;
-        if (isOwnToTotal) {
-          compareConditionBalance(
-            oldPartDefined.ownBalance,
-            newPartDefined.totalBalance,
-            "totalBalance",
-            conditionType
-          );
-        } else if (isTotalToOwn) {
-          compareConditionBalance(
-            oldPartDefined.totalBalance,
-            newPartDefined.ownBalance,
-            "ownBalance",
-            conditionType
-          );
-        } else {
-          compareConditionBalance(
-            oldPartDefined.ownBalance,
-            newPartDefined.ownBalance,
-            "ownBalance",
-            conditionType
-          );
-          compareConditionBalance(
-            oldPartDefined.totalBalance,
-            newPartDefined.totalBalance,
-            "totalBalance",
-            conditionType
-          );
-        }
-      }
-    ).exhaustive();
-  });
-  issues.push(
-    ...conditionComparator(oldCondition, newCondition).map((message) => ({
-      path: [...basePath],
-      message
-    }))
-  );
-  return issues;
-};
-var verifyEntryBackCompat = (oldEntry, newEntry, basePath) => {
-  const issues = [];
-  const flag = (path, message) => {
-    const prefix = (oldEntry.typeVersion ?? 1) === 1 ? `Entry type '${oldEntry.type}'` : `Entry type '${oldEntry.type}' version ${oldEntry.typeVersion}`;
-    issues.push({
-      path: [...basePath, ...path],
-      message: `${prefix} ${message}`
-    });
-  };
-  const oldRuntimeParameters = new Set(getSchemaObjectParameters(oldEntry));
-  const newRuntimeParameters = new Set(getSchemaObjectParameters(newEntry));
-  newRuntimeParameters.forEach((param) => {
-    if (!oldRuntimeParameters.has(param)) {
-      flag([], `new runtime parameter added: '${param}'.`);
-    }
-  });
-  if (oldEntry.description !== newEntry.description) {
-    flag(
-      ["description"],
-      `description changed from '${oldEntry.description}' to '${newEntry.description}'.`
-    );
-  }
-  const oldStaticParameters = new Map(
-    Object.entries(oldEntry.parameters ?? {})
-  );
-  const newStaticParameters = new Map(
-    Object.entries(newEntry.parameters ?? {})
-  );
-  oldStaticParameters.forEach((oldValue, oldKey) => {
-    if (!newStaticParameters.has(oldKey)) {
-      flag(["parameters"], `static parameter '${oldKey}' removed.`);
-    } else if (newStaticParameters.get(oldKey) !== oldValue) {
-      flag(
-        ["parameters", oldKey],
-        `static parameter '${oldKey}' changed from '${oldValue}' to '${newStaticParameters.get(
-          oldKey
-        )}'.`
-      );
-    }
-  });
-  newStaticParameters.forEach((newValue, newKey) => {
-    if (!oldStaticParameters.has(newKey)) {
-      flag(["parameters", newKey], `static parameter '${newKey}' added.`);
-    }
-  });
-  {
-    const oldLines = oldEntry.lines ?? [];
-    const newLines = newEntry.lines ?? [];
-    if (oldLines.length !== newLines.length) {
-      flag(
-        ["lines"],
-        `number of lines changed from ${oldLines.length} to ${newLines.length}.`
-      );
-    }
-    const oldLinesByKey = /* @__PURE__ */ new Map();
-    oldLines.forEach((line) => {
-      oldLinesByKey.set(line.key, line);
-    });
-    newLines.forEach((line, idx) => {
-      const oldLine = oldLinesByKey.get(line.key);
-      if (!oldLine) {
-        flag(["lines", idx], `line with key '${line.key}' added.`);
-        return;
-      }
-      issues.push(
-        ...verifyLineBackCompat(oldLine, line, [...basePath, "lines", idx])
-      );
-    });
-  }
-  const oldTags = new Set((oldEntry.tags ?? []).map((tag) => (0, import_object_hash.default)(tag)));
-  const newTags = new Set((newEntry.tags ?? []).map((tag) => (0, import_object_hash.default)(tag)));
-  if (!areSetsEqual(oldTags, newTags)) {
-    flag(["tags"], `tags changed.`);
-  }
-  const oldGroups = new Set(
-    (oldEntry.groups ?? []).map((group) => (0, import_object_hash.default)(group))
-  );
-  const newGroups = new Set(
-    (newEntry.groups ?? []).map((group) => (0, import_object_hash.default)(group))
-  );
-  if (!areSetsEqual(oldGroups, newGroups)) {
-    flag(["groups"], `groups changed.`);
-  }
-  {
-    const oldConditions = oldEntry.conditions ?? [];
-    const newConditions = newEntry.conditions ?? [];
-    if (oldConditions.length !== newConditions.length) {
-      flag(
-        ["conditions"],
-        `number of conditions changed from ${oldConditions.length} to ${newConditions.length}.`
-      );
-    }
-    const maxLength = Math.max(oldConditions.length, newConditions.length);
-    for (let idx = 0; idx < maxLength; idx++) {
-      const oldCondition = oldConditions[idx];
-      const newCondition = newConditions[idx];
-      if (!oldCondition && newCondition) {
-        flag(["conditions", idx], `Condition at index ${idx} added.`);
-      } else if (oldCondition && !newCondition) {
-        flag(["conditions", idx], `Condition at index ${idx} removed.`);
-      } else if (oldCondition && newCondition) {
-        issues.push(
-          ...verifyConditionBackCompat(oldCondition, newCondition, [
-            ...basePath,
-            "conditions",
-            idx
-          ])
-        );
-      }
-    }
-  }
-  return issues;
-};
-var verifyDeprecationBackCompat = (oldEntry, newEntry, oldSchemaTimestamp, basePath) => {
-  const issues = [];
-  const shouldSkipTimestampCheck = process.env.DANGEROUSLY_SKIP_DEPRECATION_TIMESTAMP_CHECK === "true" && process.env.NODE_ENV === "test";
-  if (newEntry.status === "archived" && oldEntry.status !== "archived") {
-    if (!oldEntry || oldEntry.status !== "disabled") {
-      issues.push({
-        path: [...basePath, "status"],
-        message: `Entry type '${newEntry.type}' version ${newEntry.typeVersion ?? 1} cannot be set to archived status without first being disabled for at least ${MIN_SCHEMA_LEDGER_ENTRY_DISABLED_DURATION_SECONDS} seconds.`
-      });
-      return issues;
-    }
-    if (oldSchemaTimestamp && !shouldSkipTimestampCheck) {
-      const currentTime = /* @__PURE__ */ new Date();
-      const schemaTime = new Date(oldSchemaTimestamp);
-      if (Number.isNaN(schemaTime.getTime()) || schemaTime > currentTime) {
-        issues.push({
-          path: [...basePath, "status"],
-          message: `Entry type '${newEntry.type}' version ${newEntry.typeVersion ?? 1} cannot be set to archived status. Invalid schema timestamp detected.`
-        });
-        return issues;
-      }
-      const timeSinceSchemaUpdate = (currentTime.getTime() - schemaTime.getTime()) / 1e3;
-      if (timeSinceSchemaUpdate < MIN_SCHEMA_LEDGER_ENTRY_DISABLED_DURATION_SECONDS) {
-        issues.push({
-          path: [...basePath, "status"],
-          message: `Entry type '${newEntry.type}' version ${newEntry.typeVersion ?? 1} cannot be set to archived status. It must first remain disabled for at least 45 seconds (currently ${Math.round(
-            timeSinceSchemaUpdate
-          )} seconds).`
-        });
-        return issues;
-      }
-    }
-  }
-  return issues;
-};
-var entryTypeIdentifier = (entryType, version) => `type:${entryType}:version:${version ?? "1"}`;
-var verifyEntriesBackCompat = (oldEntries, newEntries, basePath, oldSchemaTimestamp) => {
-  const issues = [];
-  const oldEntriesByKey = /* @__PURE__ */ new Map();
-  oldEntries.forEach((entry) => {
-    oldEntriesByKey.set(
-      entryTypeIdentifier(entry.type, entry.typeVersion),
-      entry
-    );
-  });
-  const newEntriesByKey = /* @__PURE__ */ new Map();
-  newEntries.forEach((entry) => {
-    newEntriesByKey.set(
-      entryTypeIdentifier(entry.type, entry.typeVersion),
-      entry
-    );
-  });
-  oldEntries.forEach((oldEntry) => {
-    if (!newEntriesByKey.has(
-      entryTypeIdentifier(oldEntry.type, oldEntry.typeVersion)
-    )) {
-      issues.push({
-        path: [...basePath],
-        message: `Entry type '${oldEntry.type}' version ${oldEntry.typeVersion ?? 1} removed.`
-      });
-    }
-  });
-  newEntries.forEach((newEntry, idx) => {
-    const oldEntry = oldEntriesByKey.get(
-      entryTypeIdentifier(newEntry.type, newEntry.typeVersion)
-    );
-    if (!oldEntry) {
-      return;
-    }
-    issues.push(
-      ...verifyEntryBackCompat(oldEntry, newEntry, [...basePath, idx])
-    );
-    if (newEntry.status === "archived") {
-      const deprecationIssues = verifyDeprecationBackCompat(
-        oldEntry,
-        newEntry,
-        oldSchemaTimestamp,
-        [...basePath, idx]
-      );
-      issues.push(...deprecationIssues);
-    }
-  });
-  return issues;
-};
-
-// ../../libs/schema-validation/utils/backcompat/payments.ts
-init_cjs_shims();
-var normalize = (value) => JSON.parse(JSON.stringify(value));
-var verifyAccountingBackCompat = (oldType, newType, basePath) => Object.values(PaymentAccountingEventKey).flatMap(
-  (event) => isEqual_default(oldType.accounting[event], newType.accounting[event]) ? [] : [
-    {
-      path: [...basePath, "accounting", event],
-      message: `accounting entry '${event}' changed.`
-    }
-  ]
-);
-var paymentTypePolicies = {
-  type: {
-    kind: "compare",
-    checks: { serializer: (paymentType) => paymentType.type, name: "type" }
-  },
-  typeVersion: {
-    kind: "compare",
-    checks: {
-      serializer: (paymentType) => paymentType.typeVersion,
-      name: "typeVersion"
-    }
-  },
-  status: {
-    kind: "compare",
-    checks: { serializer: (paymentType) => paymentType.status, name: "status" }
-  },
-  payment: {
-    kind: "compare",
-    checks: {
-      amount: {
-        serializer: (paymentType) => paymentType.payment.amount,
-        name: "payment.amount"
-      },
-      direction: {
-        serializer: (paymentType) => paymentType.payment.direction,
-        name: "payment.direction"
-      }
-    }
-  },
-  accounting: { kind: "custom", check: verifyAccountingBackCompat }
-};
-var paymentTypeCheckers = Object.values(
-  paymentTypePolicies
-).map(
-  (policy) => z(policy).returnType().with({ kind: "ignored" }, () => () => []).with({ kind: "compare" }, ({ checks }) => {
-    const comparator = createComparator(flattenChecks(checks));
-    return (oldType, newType, basePath) => comparator(oldType, newType).map((message) => ({
-      path: [...basePath],
-      message
-    }));
-  }).with({ kind: "custom" }, ({ check }) => check).exhaustive()
-);
-var paymentTypeIdentifier = (paymentType) => `type:${paymentType.type}:version:${paymentType.typeVersion}`;
-var verifyPaymentTypeBackCompat = (oldType, newType, basePath) => paymentTypeCheckers.flatMap(
-  (checker) => checker(oldType, newType, basePath).map(({ path, message }) => ({
-    path,
-    message: `Payment type '${oldType.type}' version ${oldType.typeVersion}: ${message}`
-  }))
-);
-var verifyPaymentsBackCompat = (unnormalizedOldPayments, unnormalizedNewPayments, basePath) => {
-  const oldTypes = normalize(unnormalizedOldPayments?.types ?? []);
-  const newTypes = normalize(unnormalizedNewPayments?.types ?? []);
-  const issues = [];
-  const oldTypesByKey = new Map(
-    oldTypes.map((paymentType) => [
-      paymentTypeIdentifier(paymentType),
-      paymentType
-    ])
-  );
-  const newTypesByKey = new Map(
-    newTypes.map((paymentType) => [
-      paymentTypeIdentifier(paymentType),
-      paymentType
-    ])
-  );
-  oldTypes.forEach((oldType) => {
-    if (!newTypesByKey.has(paymentTypeIdentifier(oldType))) {
-      issues.push({
-        path: [...basePath],
-        message: `Payment type '${oldType.type}' version ${oldType.typeVersion} removed.`
-      });
-    }
-  });
-  newTypes.forEach((newType, idx) => {
-    const oldType = oldTypesByKey.get(paymentTypeIdentifier(newType));
-    if (!oldType) {
-      return;
-    }
-    issues.push(
-      ...verifyPaymentTypeBackCompat(oldType, newType, [...basePath, idx])
-    );
-  });
-  return issues;
-};
-
-// ../../libs/schema-validation/utils/backcompat/verifySchemaBackCompat.ts
-var isSchemaInput = (schema) => {
-  return schema.key !== void 0;
-};
-var encodePath = (path) => path.map((part, idx) => {
-  if (idx === 0) {
-    return part;
-  }
-  if (typeof part === "number") {
-    return `[${part}]`;
-  }
-  if (typeof part === "string" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(part)) {
-    return `.${part}`;
-  }
-  return `[${JSON.stringify(part)}]`;
-}).join("");
-var isValidAccountStatusTransition = (oldStatus, newStatus) => {
-  if (oldStatus === newStatus) {
-    return true;
-  }
-  return VALID_LEDGER_ACCOUNT_STATUS_TRANSITIONS[oldStatus]?.includes(newStatus) ?? false;
-};
-var verifyCoaSchemaBackCompat = ({
-  oldSchema,
-  newSchema
-}) => {
-  const oldCoa = ChartOfAccounts.parse(oldSchema.chartOfAccounts);
-  const newCoa = parseWithError(
-    ChartOfAccounts,
-    newSchema.chartOfAccounts,
-    BadRequestError,
-    {
-      message: "Invalid schema provided"
-    }
-  );
-  assert_default(
-    newCoa.defaultCurrency?.code === oldCoa.defaultCurrency?.code && newCoa.defaultCurrency?.customCurrencyId === oldCoa.defaultCurrency?.customCurrencyId,
-    BadRequestError,
-    {
-      message: `Changing defaultCurrency is backwards-incompatible.`
-    }
-  );
-  assert_default(
-    newCoa.defaultCurrencyMode === oldCoa.defaultCurrencyMode,
-    BadRequestError,
-    {
-      message: `Changing defaultCurrencyMode is backwards-incompatible.`
-    }
-  );
-  const oldAccountPaths = [];
-  const oldAccountPathToAccount = /* @__PURE__ */ new Map();
-  const newAccountPaths = [];
-  const newAccountPathToAccount = /* @__PURE__ */ new Map();
-  const walkAccounts = (account, accountPaths, accountPathToAccount, path) => {
-    const newPath = path ? `${path}/${account.key}` : account.key;
-    accountPaths.push(newPath);
-    assert_default(account.type, BadRequestError, {
-      message: `Account type not provided for ${account.type}`
-    });
-    accountPathToAccount.set(newPath, account);
-    account.children?.forEach(
-      (child) => walkAccounts(child, accountPaths, accountPathToAccount, newPath)
-    );
-  };
-  oldCoa.accounts.forEach(
-    (account) => walkAccounts(account, oldAccountPaths, oldAccountPathToAccount)
-  );
-  newCoa.accounts.forEach(
-    (account) => walkAccounts(account, newAccountPaths, newAccountPathToAccount)
-  );
-  const accountsRemoved = oldAccountPaths.filter(
-    (path) => !newAccountPaths.includes(path)
-  );
-  assert_default(accountsRemoved.length === 0, BadRequestError, {
-    message: `Cannot delete accounts in a schema update. You removed accounts with these paths: [${accountsRemoved.join(
-      ", "
-    )}]`,
-    info: {
-      accountsRemoved
-    }
-  });
-  const schemaUpgrades = /* @__PURE__ */ new Map();
-  oldAccountPaths.forEach((path) => {
-    const oldAccount = oldAccountPathToAccount.get(path);
-    const newAccount = newAccountPathToAccount.get(path);
-    assert_default(oldAccount, InternalError, {
-      message: `Account with path ${path} not found in cache`
-    });
-    assert_default(newAccount, InternalError, {
-      message: `Account with path ${path} not found in cache`
-    });
-    assert_default(oldAccount.type === newAccount.type, BadRequestError, {
-      message: `Cannot change account type from ${oldAccount.type} to ${newAccount.type} (path: ${path}).`
-    });
-    assert_default(
-      isEqual_default(oldAccount.linkedAccount, newAccount.linkedAccount),
-      BadRequestError,
-      {
-        message: `Cannot change linked account property on account (path: ${path}).`
-      }
-    );
-    assert_default(isEqual_default(oldAccount.payment, newAccount.payment), BadRequestError, {
-      message: `Cannot change payment property on account (path: ${path}).`
-    });
-    const oldTemplate = oldAccount.template;
-    const newTemplate = newAccount.template;
-    const isTemplateChangeValid = oldTemplate === newTemplate || oldTemplate === void 0 && newTemplate === false || oldTemplate === false && newTemplate === void 0;
-    assert_default(isTemplateChangeValid, BadRequestError, {
-      message: `Cannot change template property from ${oldTemplate} to ${newTemplate} on account (path: ${path}).`
-    });
-    const normalizedOldClearing = oldAccount.clearing ?? false;
-    const normalizedNewClearing = newAccount.clearing ?? false;
-    if (!normalizedOldClearing && normalizedNewClearing) {
-      assert_default(false, BadRequestError, {
-        message: `Cannot change clearing property on active account (path: ${path}).`
-      });
-    }
-    if (normalizedOldClearing && !normalizedNewClearing) {
-      assert_default(false, BadRequestError, {
-        message: `Cannot change clearing property on active account (path: ${path}).`
-      });
-    }
-    const oldStatus = getAccountStatus(oldAccount);
-    const newStatus = getAccountStatus(newAccount);
-    assert_default(
-      isValidAccountStatusTransition(oldStatus, newStatus),
-      BadRequestError,
-      {
-        message: `Invalid account status transition from ${oldStatus} to ${newStatus} (path: ${path}). Valid transitions: active\u2192disabled, disabled\u2192archived, disabled\u2192active, archived\u2192active.`
-      }
-    );
-    if (oldStatus !== newStatus) {
-      const accountUpgrade = z(newStatus).returnType().with("active", () => "toActiveStatus").with("disabled", () => "toDisabledStatus").with("archived", () => "toArchivedStatus").exhaustive();
-      schemaUpgrades.set(accountUpgrade, [
-        ...schemaUpgrades.get(accountUpgrade) ?? [],
-        path
-      ]);
-    }
-    if (oldAccount.currencyMode === "single" && newAccount.currencyMode === "multi") {
-      schemaUpgrades.set("singleCurrencyToMultiCurrency", [
-        ...schemaUpgrades.get("singleCurrencyToMultiCurrency") ?? [],
-        path
-      ]);
-    } else {
-      assert_default(
-        oldAccount.currencyMode === newAccount.currencyMode,
-        BadRequestError,
-        {
-          message: `Cannot change account currency mode from ${oldAccount.currencyMode} to ${newAccount.currencyMode} (path: ${path}).`
-        }
-      );
-      assert_default(
-        oldAccount.currency?.code === newAccount.currency?.code,
-        BadRequestError,
-        {
-          message: `Cannot change account currency code from ${oldAccount.currency?.code} to ${newAccount.currency?.code} (path: ${path}).`
-        }
-      );
-      assert_default(
-        oldAccount.currency?.customCurrencyId === newAccount.currency?.customCurrencyId,
-        BadRequestError,
-        {
-          message: `Cannot change account custom currency id from ${oldAccount.currency?.customCurrencyId} to ${newAccount.currency?.customCurrencyId} (path: ${path}).`
-        }
-      );
-    }
-  });
-  return schemaUpgrades;
-};
-var verifyTypedEntriesBackCompat = ({
-  oldSchema: unvalidatedOldSchema,
-  newSchema: unvalidatedNewSchema
-}) => {
-  const basePath = ["ledgerEntries", "types"];
-  const newSchema = isSchemaInput(unvalidatedNewSchema) ? validateSchema(unvalidatedNewSchema) : unvalidatedNewSchema;
-  const oldSchema = isSchemaInput(unvalidatedOldSchema) ? validateSchema(unvalidatedOldSchema) : unvalidatedOldSchema;
-  const oldEntries = oldSchema.ledgerEntries?.types ?? [];
-  const newEntries = newSchema.ledgerEntries?.types ?? [];
-  let oldSchemaTimestamp;
-  if (!isSchemaInput(unvalidatedOldSchema)) {
-    if ("created" in unvalidatedOldSchema && "modified" in unvalidatedOldSchema) {
-      oldSchemaTimestamp = unvalidatedOldSchema.modified || unvalidatedOldSchema.created;
-    }
-  }
-  const issues = verifyEntriesBackCompat(
-    oldEntries,
-    newEntries,
-    basePath,
-    oldSchemaTimestamp
-  );
-  assert_default(issues.length === 0, BadRequestError, {
-    message: `The following backwards-incompatible Ledger Entry changes were detected:
-${issues.map((issue) => `At ${encodePath(issue.path)}: ${issue.message}`).join("\n")}`
-  });
-};
-var verifyPaymentTypesBackCompat = ({
-  oldSchema: unvalidatedOldSchema,
-  newSchema: unvalidatedNewSchema
-}) => {
-  const basePath = ["payments", "types"];
-  const newSchema = isSchemaInput(unvalidatedNewSchema) ? validateSchema(unvalidatedNewSchema) : unvalidatedNewSchema;
-  const oldSchema = isSchemaInput(unvalidatedOldSchema) ? validateSchema(unvalidatedOldSchema) : unvalidatedOldSchema;
-  const issues = verifyPaymentsBackCompat(
-    oldSchema.payments,
-    newSchema.payments,
-    basePath
-  );
-  assert_default(issues.length === 0, BadRequestError, {
-    message: `The following backwards-incompatible Payment Type changes were detected:
-${issues.map((issue) => `At ${encodePath(issue.path)}: ${issue.message}`).join("\n")}`
-  });
-};
-var verifySchemaBackCompat = ({
-  oldSchema,
-  newSchema
-}) => {
-  if (!oldSchema) {
-    return {
-      backwardsCompatible: true,
-      schemaUpgrades: /* @__PURE__ */ new Map()
-    };
-  }
-  let newSchemaKey;
-  if (isSchemaInput(newSchema)) {
-    newSchemaKey = newSchema.key;
-  } else {
-    newSchemaKey = newSchema.schemaKey;
-  }
-  assert_default(oldSchema.schemaKey === newSchemaKey, BadRequestError, {
-    message: `New schema key ${newSchemaKey} must match old key ${oldSchema.schemaKey}`
-  });
-  const schemaUpgrades = verifyCoaSchemaBackCompat({ oldSchema, newSchema });
-  verifyTypedEntriesBackCompat({ oldSchema, newSchema });
-  verifyPaymentTypesBackCompat({ oldSchema, newSchema });
-  return {
-    backwardsCompatible: true,
-    schemaUpgrades
-  };
-};
-
-// ../../libs/schema-validation/utils/backcompat/evaluateDeployBackCompat.ts
-var evaluateDeployBackCompat = ({
-  oldSchema,
-  newSchema,
-  hasLedgers
-}) => {
-  if (!oldSchema || !hasLedgers) {
-    return { backwardsCompatible: true, message: null };
-  }
-  try {
-    verifySchemaBackCompat({ oldSchema, newSchema });
-    return { backwardsCompatible: true, message: null };
-  } catch (e) {
-    if (e instanceof BadRequestError) {
-      return { backwardsCompatible: false, message: e.message };
-    }
-    throw e;
-  }
-};
-
-// src/utils/schemaBackCompat.ts
-var BackCompatCheckError = class extends Error {
-};
-var ComparisonSchemaError = class extends BackCompatCheckError {
-  constructor() {
-    super(...arguments);
-    this.jsonType = "comparison_schema_error";
-  }
-};
-var BackCompatError = class extends BackCompatCheckError {
-  constructor() {
-    super(...arguments);
-    this.jsonType = "backcompat_error";
-  }
-};
-var verifySchemaAgainstFile = ({
-  command,
-  schema,
-  againstPath,
-  requireEnvVariables
-}) => {
-  const [oldSchema, parseError] = parseJSON(
-    getParsedSchemaString({
-      command,
-      schemaPath: againstPath,
-      silenceNonErrorLogging: true,
-      requireEnvVariables
-    })
-  );
-  if (parseError) {
-    throw new ComparisonSchemaError(
-      `Failed to parse ${againstPath}: ${parseError.message}`
-    );
-  }
-  try {
-    validateSchemaStructure(oldSchema);
-  } catch {
-    throw new ComparisonSchemaError(
-      `${againstPath} is not a valid schema, so it cannot be compared.`
-    );
-  }
-  const { backwardsCompatible, message } = evaluateDeployBackCompat({
-    oldSchema: { ...oldSchema, schemaKey: oldSchema.key },
-    newSchema: schema,
-    hasLedgers: true
-  });
-  if (!backwardsCompatible) {
-    throw new BackCompatError(
-      `Schema is not backwards-compatible with ${againstPath}.
-${message}`
-    );
-  }
-};
-
-export {
-  BackCompatCheckError,
-  ComparisonSchemaError,
-  BackCompatError,
-  verifySchemaAgainstFile
-};