@fragment-dev/cli 2026.8.12 → 2026.8.13-1

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

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

package/dist/{chunk-5KQ5OCKA.js → chunk-2IMQAI2H.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

package/dist/{chunk-LQZUHYYU.js → chunk-4BCQFVJS.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

package/dist/{chunk-ILQG7D3T.js → chunk-63M7ILIN.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

package/dist/{chunk-J5XCGVQ6.js → chunk-7FQSPYFZ.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

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

@@ -4651,21 +4651,31 @@ 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
 });
 var BaseSchemaPaymentEntryLineInput = BaseSchemaLedgerEntryLineInput.extend({
+  amount: z.string(),
   system: SystemLineKindSchema.optional()
 });
 var BaseSchemaPaymentEntryInput = z.object({
   description: z.string().optional(),
-  lines: z.array(BaseSchemaPaymentEntryLineInput).optional()
+  lines: z.array(BaseSchemaPaymentEntryLineInput)
 });
+var SchemaPaymentEntryStatusSchema = z.enum(["active"]);
 var BaseSchemaPaymentTypeInput = z.object({
   type: z.string(),
   typeVersion: z.number().int(),
-  status: SchemaLedgerEntityStatusSchema,
+  status: SchemaPaymentEntryStatusSchema,
   payment: BaseSchemaPaymentInput,
   accounting: z.object({
     needs_confirmation_to_processing: BaseSchemaPaymentEntryInput.optional(),
@@ -6342,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`
@@ -6389,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"]
       });
@@ -6481,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 ?? {};
@@ -6501,7 +6512,8 @@ var validateLine = (entryType, entryParameters, entryHasTwoLines, entryHasAnyLin
       line.key,
       accountPath,
       accountPathToAccount,
-      parameters
+      parameters,
+      options
     )
   );
   validationResult.push(
@@ -6538,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,
@@ -6561,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) {
@@ -6585,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) => {
@@ -6602,7 +6615,8 @@ var validateBalancedLines = (entryType, entryParameters, lines, accountPathToAcc
         entryType,
         entryParameters,
         staticLines,
-        accountPathToAccount
+        accountPathToAccount,
+        options
       )
     );
   }
@@ -6612,7 +6626,8 @@ var validateBalancedLines = (entryType, entryParameters, lines, accountPathToAcc
         entryType,
         entryParameters,
         groupLines,
-        accountPathToAccount
+        accountPathToAccount,
+        options
       ).map((error) => ({
         ...error,
         message: `[repeated key '${key}'] ${error.message}`
@@ -7445,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(),
@@ -7677,6 +7971,39 @@ var SchemaLedgerEntryInput = z.object({
 var SchemaLedgerEntriesInput = z.object({
   types: z.array(SchemaLedgerEntryInput)
 });
+var SchemaPaymentLineInput = SchemaLedgerLineInput.pick({
+  key: true,
+  account: true,
+  currency: true,
+  description: true
+}).extend({
+  // Required, unlike ledger lines — payment entries have no runtime-filled
+  // variant.
+  amount: ParameterizedAmount(),
+  system: SystemLineKindSchema.optional()
+});
+var SchemaPaymentEntryInput = z.object({
+  description: ParameterizedString.optional(),
+  lines: z.array(SchemaPaymentLineInput)
+});
+var SchemaPaymentTypeInput = z.object({
+  type: SafeStringSchema,
+  typeVersion: z.number().int().positive(),
+  status: SchemaPaymentEntryStatusSchema,
+  payment: z.object({
+    amount: ParameterizedAmount(),
+    direction: PaymentTypeDirectionSchema
+  }),
+  accounting: z.object({
+    needs_confirmation_to_processing: SchemaPaymentEntryInput.optional(),
+    processing_to_settled: SchemaPaymentEntryInput
+  })
+});
+var SchemaPaymentsInput = z.object({
+  types: z.array(SchemaPaymentTypeInput).min(1, {
+    message: "At least one Payment Type is required. Omit `payments` to store a schema without Payment Types."
+  })
+});
 var LedgerConsistencyConfigSchema = ConsistencyConfigSchema(
   ["entries"],
   {}
@@ -7706,11 +8033,19 @@ var Schema = z.object({
   ),
   chartOfAccounts: ChartOfAccounts,
   ledgerEntries: SchemaLedgerEntriesInput.optional(),
+  // TODO (FRA-7422): validate payment types beyond the structural parse.
+  payments: SchemaPaymentsInput.optional(),
   consistencyConfig: z.optional(LedgerConsistencyConfigSchema),
   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
@@ -7722,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-GYHXNIWR.js → chunk-G353NPK6.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

package/dist/{chunk-PQFLP34K.js → chunk-GXPUQEAI.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

package/dist/{chunk-4QAIVY4H.js → chunk-HVQUC54T.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

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

@@ -3,37 +3,37 @@ import {
 } from "./chunk-JFF37Z5K.js";
 import {
   Workspace
-} from "./chunk-ILQG7D3T.js";
+} from "./chunk-63M7ILIN.js";
 import {
   QuerySchemas
-} from "./chunk-4QAIVY4H.js";
+} from "./chunk-HVQUC54T.js";
 import {
   ReverseLedgerEntry
-} from "./chunk-GYHXNIWR.js";
+} from "./chunk-G353NPK6.js";
 import {
   Start
 } from "./chunk-TOXMGEU7.js";
 import {
   StoreSchema
-} from "./chunk-VPMGSMMO.js";
+} from "./chunk-VCANHQTI.js";
 import {
   Token
-} from "./chunk-REHGTHTG.js";
+} from "./chunk-URUHIS5X.js";
 import {
   UpdateLedgerAccount
-} from "./chunk-7LZ2UEOL.js";
+} from "./chunk-TUQGCEII.js";
 import {
   Update
 } from "./chunk-IXX2EVIM.js";
 import {
   VerifySchema
-} from "./chunk-7ZKTVCSL.js";
+} from "./chunk-JCJNNUTD.js";
 import {
   GenGraphQL
-} from "./chunk-RSG3R56J.js";
+} from "./chunk-25RM4I6G.js";
 import {
   GetSchema
-} from "./chunk-KZW3FS6C.js";
+} from "./chunk-JDSPZQFF.js";
 import {
   Init
 } from "./chunk-K5RBCJWQ.js";
@@ -42,37 +42,37 @@ import {
 } from "./chunk-IYYWZCZE.js";
 import {
   MigrateLedgerEntry
-} from "./chunk-BMVJIALA.js";
+} from "./chunk-TKGH62DQ.js";
 import {
   QueryLedgerAccounts
-} from "./chunk-ZGSMOYIU.js";
+} from "./chunk-K3P7VNMI.js";
 import {
   QueryLedgers
-} from "./chunk-MPWRVHST.js";
+} from "./chunk-QAFH3E4Q.js";
 import {
   GetSchema as GetSchema2
-} from "./chunk-LQZUHYYU.js";
+} from "./chunk-4BCQFVJS.js";
 import {
   AddLedgerEntry
-} from "./chunk-F4FOZXDF.js";
+} from "./chunk-SI23PX53.js";
 import {
   ApiClientCreate
 } from "./chunk-5JLMMFER.js";
 import {
   CreateCustomLink
-} from "./chunk-CTS6NEPI.js";
+} from "./chunk-MW6SJUWV.js";
 import {
   CreateLedger
-} from "./chunk-D3DHORM5.js";
+} from "./chunk-XWX7CFJN.js";
 import {
   DeleteCustomTxs
-} from "./chunk-J5XCGVQ6.js";
+} from "./chunk-7FQSPYFZ.js";
 import {
   DeleteLedger
-} from "./chunk-PQFLP34K.js";
+} from "./chunk-GXPUQEAI.js";
 import {
   DeleteSchema
-} from "./chunk-5KQ5OCKA.js";
+} from "./chunk-2IMQAI2H.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

package/dist/{chunk-7ZKTVCSL.js → chunk-JCJNNUTD.js}

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

package/dist/{chunk-KZW3FS6C.js → chunk-JDSPZQFF.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-KAGCPC3G.js";
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

package/dist/{chunk-ZGSMOYIU.js → chunk-K3P7VNMI.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";

package/dist/{chunk-CTS6NEPI.js → chunk-MW6SJUWV.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-HRTIPO6Y.js";
+} from "./chunk-YVL4XU33.js";
 import {
   require_lib
 } from "./chunk-W2V2ILHS.js";