@fragment-dev/cli 2026.8.12-1 → 2026.8.12-4

package/dist/{chunk-NNQ7VY2C.js → chunk-25RM4I6G.js}

@@ -7,7 +7,7 @@ import {
 import {
   Schema,
   parseWithError
-} from "./chunk-SPATLADZ.js";
+} from "./chunk-D67ACT4J.js";
 import {
   formatValidationErrors,
   logValidationErrors

package/dist/{chunk-SPATLADZ.js → chunk-D67ACT4J.js}

@@ -4651,6 +4651,14 @@ var SystemLineKind = {
   payment_fee_line: "payment_fee_line"
 };
 var SystemLineKindSchema = z.nativeEnum(SystemLineKind);
+var SystemLineParameterName = {
+  payment_settlement_line: "payment_amount",
+  payment_fee_line: "fragment_fee_amount"
+};
+var SYSTEM_LINE_AMOUNT = {
+  [SystemLineKind.payment_settlement_line]: `{{${SystemLineParameterName.payment_settlement_line}}}`,
+  [SystemLineKind.payment_fee_line]: `-{{${SystemLineParameterName.payment_fee_line}}}`
+};
 var BaseSchemaPaymentInput = z.object({
   amount: z.string(),
   direction: PaymentTypeDirectionSchema
@@ -6344,7 +6352,7 @@ var getFullyParameterizedAccount = (accountPath, accountPathToAccount, entryPara
   });
   return account;
 };
-var validateLineAccount = (entryType, lineKey, accountPath, accountPathToAccount, entryParameters) => {
+var validateLineAccount = (entryType, lineKey, accountPath, accountPathToAccount, entryParameters, options) => {
   const validationResults = safeGetZodErrors(
     ParameterizedString.refine((s2) => s2.length > 0, {
       message: `Ledger Line (${lineKey}) in Ledger Entry (${entryType}) must specify a Ledger Account path`
@@ -6391,8 +6399,9 @@ var validateLineAccount = (entryType, lineKey, accountPath, accountPathToAccount
     });
   }
   try {
-    if (account && getSchemaAccountCategory(account) === "Payment" /* Payment */) {
+    if (!options?.allowPaymentAccount && account && getSchemaAccountCategory(account) === "Payment" /* Payment */) {
       validationResults.push({
+        code: "payment_account_in_ledger_entry",
         message: `Ledger Entries cannot post to Payment Accounts. (entry: ${entryType} | line key: ${lineKey} | account path: ${accountPath})`,
         path: ["account", "path"]
       });
@@ -6483,7 +6492,7 @@ var validateLineTx = (tx, accountPath, accountPathToAccount, entryParameters, li
   }
   return validationResults;
 };
-var validateLine = (entryType, entryParameters, entryHasTwoLines, entryHasAnyLineWithTx, line, accountPathToAccount) => {
+var validateLine = (entryType, entryParameters, entryHasTwoLines, entryHasAnyLineWithTx, line, accountPathToAccount, options) => {
   const validationResult = validateLineKey(line.key);
   const accountPath = line.account.path;
   const parameters = entryParameters ?? {};
@@ -6503,7 +6512,8 @@ var validateLine = (entryType, entryParameters, entryHasTwoLines, entryHasAnyLin
       line.key,
       accountPath,
       accountPathToAccount,
-      parameters
+      parameters,
+      options
     )
   );
   validationResult.push(
@@ -6540,7 +6550,7 @@ var validateLine = (entryType, entryParameters, entryHasTwoLines, entryHasAnyLin
 var isKDefined = (k2, line) => {
   return line[k2] !== void 0;
 };
-var validateBalancedLineGroup = (entryType, entryParameters, lines, accountPathToAccount) => {
+var validateBalancedLineGroup = (entryType, entryParameters, lines, accountPathToAccount, options) => {
   const parameterizedLines = lines.map(
     (line) => parameterizeSchemaLedgerLineInput({
       line,
@@ -6563,7 +6573,8 @@ var validateBalancedLineGroup = (entryType, entryParameters, lines, accountPathT
       lines.length === 2,
       lines.some((l) => l.tx),
       line,
-      accountPathToAccount
+      accountPathToAccount,
+      options
     ).length === 0
   );
   if (parameterizedLines.length < lines.length) {
@@ -6587,7 +6598,7 @@ var validateBalancedLineGroup = (entryType, entryParameters, lines, accountPathT
   }
   return [];
 };
-var validateBalancedLines = (entryType, entryParameters, lines, accountPathToAccount) => {
+var validateBalancedLines = (entryType, entryParameters, lines, accountPathToAccount, options) => {
   const staticLines = lines.filter((line) => !line.repeated);
   const repeatedGroups = /* @__PURE__ */ new Map();
   lines.forEach((line) => {
@@ -6604,7 +6615,8 @@ var validateBalancedLines = (entryType, entryParameters, lines, accountPathToAcc
         entryType,
         entryParameters,
         staticLines,
-        accountPathToAccount
+        accountPathToAccount,
+        options
       )
     );
   }
@@ -6614,7 +6626,8 @@ var validateBalancedLines = (entryType, entryParameters, lines, accountPathToAcc
         entryType,
         entryParameters,
         groupLines,
-        accountPathToAccount
+        accountPathToAccount,
+        options
       ).map((error) => ({
         ...error,
         message: `[repeated key '${key}'] ${error.message}`
@@ -7447,6 +7460,285 @@ var validateGroup = (group, validatedCoA, validatedEntries, index) => {
   return errors;
 };
 
+// ../../libs/schema-validation/utils/transformers/payments.ts
+init_cjs_shims();
+var amountMatchesSystemLine = (amount, system) => amount === SYSTEM_LINE_AMOUNT[system];
+var getAccountCategoryOrUndefined = (account) => {
+  try {
+    return getSchemaAccountCategory(account);
+  } catch (e2) {
+    if (e2 instanceof AccountCategoryMutualExclusionError) {
+      return void 0;
+    }
+    throw e2;
+  }
+};
+var findPaymentAccountPath = (accountPathToAccount) => Array.from(accountPathToAccount.entries()).find(
+  ([, account]) => getAccountCategoryOrUndefined(account) === "Payment" /* Payment */
+)?.[0];
+var fillInPaymentEntryLines = (entry, accountPathToAccount) => (entry.lines ?? []).map((line, idx) => {
+  const path = line.account?.path ? getStructuralPath(line.account.path) : void 0;
+  return {
+    ...line,
+    account: line.account ?? { path: "" },
+    key: line.key ?? `line-${idx}`,
+    amount: line.amount ?? "",
+    currency: line.currency ?? (path ? accountPathToAccount.get(path)?.currency : void 0)
+  };
+});
+var validateSystemLines = ({
+  lines,
+  event,
+  entryIdentity,
+  paymentAccountPath
+}) => {
+  const errors = [];
+  if (event !== PaymentEventKey.processing_to_settled) {
+    lines.forEach((line, idx) => {
+      if (line.system) {
+        errors.push({
+          path: ["lines", idx, "system"],
+          message: `System lines are only allowed on the '${PaymentEventKey.processing_to_settled}' entry. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+    });
+    return errors;
+  }
+  Object.values(SystemLineKind).forEach((system) => {
+    const count = lines.filter((line) => line.system === system).length;
+    if (count !== 1) {
+      errors.push({
+        path: ["lines"],
+        message: `Payment entry (${entryIdentity}) must have exactly one line with system '${system}', found ${count}.`
+      });
+    }
+  });
+  lines.forEach((line, idx) => {
+    const isPaymentAccountLine = paymentAccountPath !== void 0 && getStructuralPath(line.account.path) === paymentAccountPath;
+    if (line.system) {
+      if (paymentAccountPath !== void 0 && !isPaymentAccountLine) {
+        errors.push({
+          path: ["lines", idx, "account", "path"],
+          message: `System line '${line.system}' must post to the Payment Account. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+      if (!amountMatchesSystemLine(line.amount, line.system)) {
+        errors.push({
+          path: ["lines", idx, "amount"],
+          message: `System line '${line.system}' must have amount '${SYSTEM_LINE_AMOUNT[line.system]}'. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+    } else if (isPaymentAccountLine) {
+      errors.push({
+        path: ["lines", idx, "system"],
+        message: `Only system lines may post to the Payment Account. (payment entry: ${entryIdentity} | line key: ${line.key})`
+      });
+    }
+  });
+  return errors;
+};
+var validatePaymentEntry = ({
+  entry,
+  event,
+  entryIdentity,
+  accountPathToAccount,
+  paymentAccountPath
+}) => {
+  const errors = [];
+  errors.push(...validateDescription(entry.description));
+  const lines = fillInPaymentEntryLines(entry, accountPathToAccount);
+  if (lines.length > MAX_ENTRY_LINES) {
+    errors.push({
+      path: ["lines"],
+      message: `Payment entry (${entryIdentity}) has too many lines. The maximum allowed is ${MAX_ENTRY_LINES}, but this entry has ${lines.length}.`
+    });
+  }
+  const allowPaymentAccount = event === PaymentEventKey.processing_to_settled;
+  errors.push(
+    ...lines.flatMap((line, idx) => {
+      const lineErrors = [];
+      if (line.tx) {
+        lineErrors.push({
+          path: ["tx"],
+          message: `Payment entry lines cannot specify tx matches. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+      if (line.repeated) {
+        lineErrors.push({
+          path: ["repeated"],
+          message: `Payment entry lines cannot be repeated. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+      if (line.tags?.length) {
+        lineErrors.push({
+          path: ["tags"],
+          message: `Payment entry lines cannot specify tags. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+      const account = accountPathToAccount.get(
+        getStructuralPath(line.account.path)
+      );
+      if (account && getAccountCategoryOrUndefined(account) === "Linked" /* Linked */) {
+        lineErrors.push({
+          path: ["account", "path"],
+          message: `Payment entry lines cannot post to Linked Accounts. (payment entry: ${entryIdentity} | line key: ${line.key})`
+        });
+      }
+      lineErrors.push(
+        ...validateLine(
+          entryIdentity,
+          void 0,
+          lines.length === 2,
+          false,
+          line,
+          accountPathToAccount,
+          { allowPaymentAccount }
+        ).filter(({ path }) => path[0] !== "tx")
+      );
+      return lineErrors.map(({ path, ...rest }) => ({
+        path: ["lines", idx, ...path],
+        ...rest
+      }));
+    })
+  );
+  errors.push(
+    ...validateUniqueByKey({
+      key: "key",
+      items: lines,
+      pathPrefix: ["lines"],
+      getErrorMessage: (item) => `Payment entry (${entryIdentity}) already has a line with key '${item.key}'`
+    })
+  );
+  errors.push(
+    ...validateBalancedLines(
+      entryIdentity,
+      void 0,
+      lines,
+      accountPathToAccount,
+      {
+        allowPaymentAccount
+      }
+    )
+  );
+  errors.push(
+    ...validateSystemLines({ lines, event, entryIdentity, paymentAccountPath })
+  );
+  return errors;
+};
+var validatePaymentType = ({
+  paymentType,
+  accountPathToAccount,
+  paymentAccountPath
+}) => {
+  const errors = validateNonEmptySafeString({
+    value: paymentType.type,
+    path: ["type"],
+    name: "type",
+    entityName: "Payment Type"
+  });
+  if (paymentType.typeVersion !== 1) {
+    errors.push({
+      path: ["typeVersion"],
+      message: `Payment Type (${paymentType.type}) must have typeVersion 1.`
+    });
+  }
+  if (paymentType.payment.direction !== PaymentTypeDirection.payin) {
+    errors.push({
+      path: ["payment", "direction"],
+      message: `Payment Type (${paymentType.type}) must have direction '${PaymentTypeDirection.payin}'. Direction '${PaymentTypeDirection.payout}' is not yet supported.`
+    });
+  }
+  if (!paymentType.payment.amount.trim()) {
+    errors.push({
+      path: ["payment", "amount"],
+      message: `Payment Type (${paymentType.type}) must specify a payment amount.`
+    });
+  } else {
+    errors.push(
+      ...safeGetZodErrors(ParameterizedAmount(), paymentType.payment.amount, [
+        "payment",
+        "amount"
+      ])
+    );
+  }
+  Object.keys(paymentType.accounting).filter((event) => !(event in PaymentEventKey)).forEach((event) => {
+    errors.push({
+      path: ["accounting", event],
+      message: `Payment Type (${paymentType.type}) has unknown accounting event '${event}'. Supported events: ${Object.values(
+        PaymentEventKey
+      ).join(", ")}.`
+    });
+  });
+  if (!paymentType.accounting.processing_to_settled) {
+    errors.push({
+      path: ["accounting", PaymentEventKey.processing_to_settled],
+      message: `Payment Type (${paymentType.type}) must define a '${PaymentEventKey.processing_to_settled}' entry.`
+    });
+  }
+  errors.push(
+    ...Object.values(PaymentEventKey).flatMap((event) => {
+      const entry = paymentType.accounting[event];
+      if (!entry) {
+        return [];
+      }
+      return validatePaymentEntry({
+        entry,
+        event,
+        entryIdentity: `${paymentType.type}.${paymentType.typeVersion}.${event}`,
+        accountPathToAccount,
+        paymentAccountPath
+      }).map(({ path, ...rest }) => ({
+        path: ["accounting", event, ...path],
+        ...rest
+      }));
+    })
+  );
+  return errors;
+};
+var transformAndValidatePayments = ({
+  payments,
+  validatedCoA
+}) => {
+  const accountPathToAccount = getStructuralPathToAccount(validatedCoA);
+  const paymentAccountPath = findPaymentAccountPath(accountPathToAccount);
+  const errors = [];
+  if (payments.types.length > 0 && paymentAccountPath === void 0) {
+    errors.push({
+      path: ["types"],
+      message: `Schema must contain a Payment Account to define Payment Types.`
+    });
+  }
+  errors.push(
+    ...Array.from(
+      groupByMap(
+        payments.types.map((paymentType, idx) => [paymentType, idx]),
+        ([paymentType]) => `${paymentType.type}:${paymentType.typeVersion}`
+      ).values()
+    ).filter((group) => group.length > 1).flatMap(
+      (group) => group.map(([paymentType, idx]) => ({
+        message: `Payment Types cannot have duplicate types '${paymentType.type}'`,
+        path: ["types", idx, "type"]
+      }))
+    )
+  );
+  errors.push(
+    ...payments.types.flatMap(
+      (paymentType, idx) => validatePaymentType({
+        paymentType,
+        accountPathToAccount,
+        paymentAccountPath
+      }).map(({ path, ...rest }) => ({
+        path: ["types", idx, ...path],
+        ...rest
+      }))
+    )
+  );
+  return {
+    filledIn: payments,
+    errors
+  };
+};
+
 // ../../libs/schema-validation/types.ts
 var SchemaCurrencyMatchInput2 = z.object({
   customCurrencyId: ParameterizedString.optional(),
@@ -7747,7 +8039,13 @@ var Schema = z.object({
   scenes: z.array(Scene).optional(),
   groups: z.array(SchemaEntryGroup).optional()
 }).transform((schema, ctx) => {
-  const { chartOfAccounts, ledgerEntries, consistencyConfig, groups } = schema;
+  const {
+    chartOfAccounts,
+    ledgerEntries,
+    consistencyConfig,
+    groups,
+    payments
+  } = schema;
   const { errors, filledIn: validatedLedgerEntries } = transformAndValidateEntries({
     ledgerEntries: ledgerEntries ?? { types: [] },
     validatedCoA: chartOfAccounts
@@ -7759,6 +8057,16 @@ var Schema = z.object({
       path
     })
   );
+  transformAndValidatePayments({
+    payments: payments ?? { types: [] },
+    validatedCoA: chartOfAccounts
+  }).errors.map((e2) => ({ ...e2, path: ["payments", ...e2.path] })).forEach(
+    ({ message, path }) => ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message,
+      path
+    })
+  );
   if (groups && groups.length > 0) {
     groups.forEach((group, index) => {
       const groupErrors = validateGroup(

package/dist/{chunk-YXLQQEPT.js → chunk-ISIHYAS2.js}

@@ -27,10 +27,10 @@ import {
 } from "./chunk-IXX2EVIM.js";
 import {
   VerifySchema
-} from "./chunk-HQFWYLCJ.js";
+} from "./chunk-JCJNNUTD.js";
 import {
   GenGraphQL
-} from "./chunk-NNQ7VY2C.js";
+} from "./chunk-25RM4I6G.js";
 import {
   GetSchema
 } from "./chunk-JDSPZQFF.js";

package/dist/{chunk-HQFWYLCJ.js → chunk-JCJNNUTD.js}

@@ -2,7 +2,7 @@ import {
   extractSchemaMetadata,
   isJsonParseError,
   validateSchemaStructure
-} from "./chunk-Z7BQVKJE.js";
+} from "./chunk-MXE6IHUJ.js";
 import {
   DEFAULT_SCHEMA_PATH
 } from "./chunk-A4BSWX5D.js";

package/dist/{chunk-Z7BQVKJE.js → chunk-MXE6IHUJ.js}

@@ -1,7 +1,7 @@
 import {
   Schema,
   parseWithError
-} from "./chunk-SPATLADZ.js";
+} from "./chunk-D67ACT4J.js";
 import {
   formatValidationErrors
 } from "./chunk-W5FV2YSN.js";

package/dist/commands/gen-graphql.js

@@ -1,10 +1,10 @@
 import {
   GenGraphQL
-} from "../chunk-NNQ7VY2C.js";
+} from "../chunk-25RM4I6G.js";
 import "../chunk-BMLIRDHA.js";
 import "../chunk-FMY4RHS4.js";
 import "../chunk-X5KIPJRF.js";
-import "../chunk-SPATLADZ.js";
+import "../chunk-D67ACT4J.js";
 import "../chunk-W5FV2YSN.js";
 import "../chunk-V6GWSE3B.js";
 import "../chunk-LRQRC5Z7.js";

package/dist/commands/verify-schema.js

@@ -1,9 +1,9 @@
 import {
   VerifySchema
-} from "../chunk-HQFWYLCJ.js";
-import "../chunk-Z7BQVKJE.js";
+} from "../chunk-JCJNNUTD.js";
+import "../chunk-MXE6IHUJ.js";
 import "../chunk-A4BSWX5D.js";
-import "../chunk-SPATLADZ.js";
+import "../chunk-D67ACT4J.js";
 import "../chunk-W5FV2YSN.js";
 import "../chunk-V6GWSE3B.js";
 import "../chunk-LRQRC5Z7.js";

package/dist/commands.js

@@ -1,6 +1,6 @@
 import {
   COMMANDS
-} from "./chunk-YXLQQEPT.js";
+} from "./chunk-ISIHYAS2.js";
 import "./chunk-JFF37Z5K.js";
 import "./chunk-63M7ILIN.js";
 import "./chunk-HVQUC54T.js";
@@ -10,14 +10,14 @@ import "./chunk-VCANHQTI.js";
 import "./chunk-URUHIS5X.js";
 import "./chunk-TUQGCEII.js";
 import "./chunk-IXX2EVIM.js";
-import "./chunk-HQFWYLCJ.js";
-import "./chunk-Z7BQVKJE.js";
+import "./chunk-JCJNNUTD.js";
+import "./chunk-MXE6IHUJ.js";
 import "./chunk-A4BSWX5D.js";
-import "./chunk-NNQ7VY2C.js";
+import "./chunk-25RM4I6G.js";
 import "./chunk-BMLIRDHA.js";
 import "./chunk-FMY4RHS4.js";
 import "./chunk-X5KIPJRF.js";
-import "./chunk-SPATLADZ.js";
+import "./chunk-D67ACT4J.js";
 import "./chunk-W5FV2YSN.js";
 import "./chunk-V6GWSE3B.js";
 import "./chunk-LRQRC5Z7.js";

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   COMMANDS
-} from "./chunk-YXLQQEPT.js";
+} from "./chunk-ISIHYAS2.js";
 import "./chunk-JFF37Z5K.js";
 import "./chunk-63M7ILIN.js";
 import "./chunk-HVQUC54T.js";
@@ -10,14 +10,14 @@ import "./chunk-VCANHQTI.js";
 import "./chunk-URUHIS5X.js";
 import "./chunk-TUQGCEII.js";
 import "./chunk-IXX2EVIM.js";
-import "./chunk-HQFWYLCJ.js";
-import "./chunk-Z7BQVKJE.js";
+import "./chunk-JCJNNUTD.js";
+import "./chunk-MXE6IHUJ.js";
 import "./chunk-A4BSWX5D.js";
-import "./chunk-NNQ7VY2C.js";
+import "./chunk-25RM4I6G.js";
 import "./chunk-BMLIRDHA.js";
 import "./chunk-FMY4RHS4.js";
 import "./chunk-X5KIPJRF.js";
-import "./chunk-SPATLADZ.js";
+import "./chunk-D67ACT4J.js";
 import "./chunk-W5FV2YSN.js";
 import "./chunk-V6GWSE3B.js";
 import "./chunk-LRQRC5Z7.js";

package/dist/utils/schemaValidation.js

@@ -3,8 +3,8 @@ import {
   extractSchemaMetadata,
   isJsonParseError,
   validateSchemaStructure
-} from "../chunk-Z7BQVKJE.js";
-import "../chunk-SPATLADZ.js";
+} from "../chunk-MXE6IHUJ.js";
+import "../chunk-D67ACT4J.js";
 import "../chunk-W5FV2YSN.js";
 import "../chunk-V6GWSE3B.js";
 import "../chunk-LRQRC5Z7.js";

package/oclif.manifest.json

@@ -1096,5 +1096,5 @@
       "help": "Generate GraphQL queries from your Schema for your SDK."
     }
   },
-  "version": "2026.8.12-1"
+  "version": "2026.8.12-4"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fragment-dev/cli",
-  "version": "2026.8.12-1",
+  "version": "2026.8.12-4",
   "description": "FRAGMENT CLI",
   "author": "hello@fragment.dev",
   "bin": {