@fragment-dev/cli 2026.10.1-3 → 2026.10.1-6

package/dist/chunk-NT74GT6W.js

@@ -0,0 +1,1287 @@
+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
+};