@fragment-dev/cli 2026.9.8-9 → 2026.9.9-1

package/dist/{chunk-TLKQCSIZ.js → chunk-2SKJI4RI.js}

@@ -1,6 +1,6 @@
 import {
   AuthenticatedCommand
-} from "./chunk-I7JOAHOD.js";
+} from "./chunk-RWZJWPVV.js";
 import {
   require_lib
 } from "./chunk-W33MLXYW.js";

package/dist/{chunk-62V42D7I.js → chunk-2UUZOEA7.js}

@@ -5,7 +5,7 @@ import {
   getStructuralPath,
   getStructuralSubpaths,
   getSubpaths
-} from "./chunk-XCOAZ3QX.js";
+} from "./chunk-PUON7HP5.js";
 import {
   BadRequestError,
   CurrencyMatchInputSchema,
@@ -20,9 +20,10 @@ import {
   assert_default,
   currencyCodes,
   getStringParameters,
+  mapValues_default,
   safe,
   z
-} from "./chunk-AT22ZHOC.js";
+} from "./chunk-3AACKVGA.js";
 import {
   __commonJS,
   __toESM,
@@ -4700,13 +4701,31 @@ var SceneEntrySchema = z.object({
   typeVersion: z.number().int().positive().optional(),
   parameters: z.record(SafeRecordKey, z.string())
 });
-var SceneEventSchema = z.object({
+var ScenePaymentSchema = z.object({
+  ik: z.string(),
+  type: z.string(),
+  typeVersion: z.number().int().positive().optional(),
+  parameters: z.record(SafeRecordKey, z.string())
+});
+var SceneLedgerEventSchema = z.object({
   eventType: z.literal("entry"),
   entry: SceneEntrySchema
 });
+var ScenePaymentEventSchema = z.object({
+  eventType: z.literal("payment"),
+  payment: z.object({
+    ik: z.string(),
+    event: PaymentEventKeySchema
+  })
+});
+var SceneEventSchema = z.discriminatedUnion("eventType", [
+  SceneLedgerEventSchema,
+  ScenePaymentEventSchema
+]);
 var BaseScene = z.object({
   name: z.string(),
-  events: z.array(SceneEventSchema)
+  events: z.array(SceneEventSchema),
+  payments: z.array(ScenePaymentSchema).optional()
 });
 var EntryKey = z.object({
   type: SafeStringSchema,
@@ -7511,6 +7530,17 @@ var validateGroup = (group, validatedCoA, validatedEntries, index) => {
 
 // ../../libs/schema-validation/utils/transformers/payments.ts
 init_cjs_shims();
+
+// ../../libs/types/paymentEntryType.ts
+init_cjs_shims();
+var PAYMENT_ENTRY_TYPE_PREFIX = "payment";
+var makePaymentEntryTypePrefix = (paymentType) => (
+  // Both halves are SafeStrings and `_` is not a delimiter character, so the
+  // concatenation is a SafeString without a runtime re-parse.
+  `${PAYMENT_ENTRY_TYPE_PREFIX}_${paymentType}_`
+);
+
+// ../../libs/schema-validation/utils/transformers/payments.ts
 var amountMatchesSystemLine = (amount, system) => amount === SYSTEM_LINE_AMOUNT[system];
 var getAccountCategoryOrUndefined = (account) => {
   try {
@@ -7784,6 +7814,26 @@ var validateUniquePaymentTypes = ({
     path: [...pathPrefix, idx, "type"]
   }))
 );
+var validateReservedPaymentEntryTypes = ({
+  ledgerEntryTypes,
+  paymentTypes
+}) => {
+  const reservedNamespaces = paymentTypes.map(({ type }) => ({
+    paymentType: type,
+    prefix: makePaymentEntryTypePrefix(type)
+  }));
+  return ledgerEntryTypes.flatMap((entry, idx) => {
+    const reservedBy = reservedNamespaces.find(
+      ({ prefix }) => entry.type.startsWith(prefix)
+    );
+    return reservedBy === void 0 ? [] : [
+      {
+        path: ["types", idx, "type"],
+        message: `Entry (${entry.type}) is in the '${reservedBy.prefix}' namespace reserved for the entries Payment Type (${reservedBy.paymentType}) posts. Rename one of them.`
+      }
+    ];
+  });
+};
 var transformAndValidatePayments = ({
   payments,
   validatedCoA
@@ -7941,6 +7991,42 @@ var parameterizeSchemaLedgerLineInput = ({
   });
   return fullLine;
 };
+var enrichSchemaLines = ({
+  lines,
+  entryParameters,
+  accountPathToAccount
+}) => lines.map((line) => {
+  const parameterizedLine = parameterizeSchemaLedgerLineInput({
+    line,
+    entryParameters
+  });
+  const accountPath = parameterizedLine.account.path;
+  const structuralPath = getStructuralPath(accountPath);
+  const fullParameterizedAccount = accountPathToAccount.get(structuralPath);
+  const account = (
+    // TODO: this makes Steven and Jerry very sad, lets fix it later.
+    fullParameterizedAccount && reparameterizeSchemaLedgerAccountInput({
+      account: fullParameterizedAccount,
+      entryParameters
+    })
+  );
+  const currency = parameterizedLine.currency || account?.currency || { code: "USD" };
+  return {
+    ...parameterizedLine,
+    parameters: parameterizedLine.parameters.concat(
+      account ? account.parameters : []
+    ),
+    // INC-62: We need to use the user-provided path for the account.
+    //         Do not assign it to account.path as it's a shared object
+    //         across entries.
+    account: {
+      ...account,
+      path: accountPath
+    },
+    accountPath,
+    currency
+  };
+});
 var SchemaInt96ConditionInput = z.object({
   eq: ParameterizedString.optional(),
   lte: ParameterizedString.optional(),
@@ -8053,6 +8139,23 @@ var SchemaLedgerEntryInput = z.object({
 var SchemaLedgerEntriesInput = z.object({
   types: z.array(SchemaLedgerEntryInput)
 });
+var enrichJournalEntry = ({
+  entry,
+  accountPathToAccount
+}) => ({
+  ...entry,
+  conditions: entry.conditions?.map(
+    (condition) => parameterizeSchemaLedgerEntryConditionInput({
+      condition,
+      entryParameters: entry.parameters
+    })
+  ),
+  lines: entry.lines && enrichSchemaLines({
+    lines: entry.lines,
+    entryParameters: entry.parameters,
+    accountPathToAccount
+  })
+});
 var SchemaPaymentLineInput = SchemaLedgerLineInput.pick({
   key: true,
   account: true,
@@ -8081,6 +8184,33 @@ var SchemaPaymentTypeInput = z.object({
     processing_to_settled: SchemaPaymentEntryInput
   })
 });
+var enrichPaymentEntry = ({
+  entry,
+  accountPathToAccount
+}) => ({
+  ...entry,
+  lines: enrichSchemaLines({
+    lines: entry.lines,
+    // Payment entries hold no static parameters — every parameter is supplied
+    // per payment when the entry posts.
+    entryParameters: void 0,
+    accountPathToAccount
+  })
+});
+var enrichPaymentType = ({
+  paymentType,
+  accountPathToAccount
+}) => {
+  const enrichEntry = (entry) => enrichPaymentEntry({ entry, accountPathToAccount });
+  const { processing_to_settled: settled, ...optionalEvents } = paymentType.accounting;
+  return {
+    ...paymentType,
+    accounting: {
+      ...mapValues_default(optionalEvents, (entry) => entry && enrichEntry(entry)),
+      processing_to_settled: enrichEntry(settled)
+    }
+  };
+};
 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."
@@ -8090,20 +8220,61 @@ var LedgerConsistencyConfigSchema = ConsistencyConfigSchema(
   ["entries"],
   {}
 );
+var SceneParameters = z.unknown().refine((value) => typeof value === "object", {
+  message: "Parameters must be an object"
+}).transform((value) => z.record(z.string()).parse(value));
 var SceneLedgerEntry = z.object({
   type: SafeStringSchema,
   typeVersion: z.optional(z.number().int().positive()),
-  parameters: z.unknown().refine((value) => typeof value === "object", {
-    message: "Parameters must be an object"
-  }).transform((value) => z.record(z.string()).parse(value))
+  parameters: SceneParameters
 });
-var SceneEvent = z.object({
-  eventType: z.literal("entry"),
-  entry: SceneLedgerEntry
+var ScenePayment = z.object({
+  ik: SafeStringSchema,
+  type: SafeStringSchema,
+  typeVersion: z.optional(z.number().int().positive()),
+  parameters: SceneParameters
+});
+var ScenePaymentEvent = z.object({
+  ik: SafeStringSchema,
+  event: PaymentEventKeySchema
 });
+var SceneEvent = z.object({
+  eventType: z.enum(["entry", "payment"]),
+  entry: z.optional(SceneLedgerEntry),
+  payment: z.optional(ScenePaymentEvent)
+}).pipe(
+  z.discriminatedUnion("eventType", [
+    z.object({ eventType: z.literal("entry"), entry: SceneLedgerEntry }),
+    z.object({ eventType: z.literal("payment"), payment: ScenePaymentEvent })
+  ])
+);
 var Scene = z.object({
   name: SafeStringSchema,
-  events: z.array(SceneEvent)
+  events: z.array(SceneEvent),
+  payments: z.optional(z.array(ScenePayment))
+}).superRefine((scene, ctx) => {
+  const declaredIks = /* @__PURE__ */ new Set();
+  (scene.payments ?? []).forEach((payment, index) => {
+    if (declaredIks.has(payment.ik)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["payments", index, "ik"],
+        message: `Duplicate simulated payment ik '${payment.ik}' in Scene '${scene.name}'.`
+      });
+    }
+    declaredIks.add(payment.ik);
+  });
+  scene.events.forEach((event, index) => {
+    if (event.eventType !== "payment")
+      return;
+    if (declaredIks.has(event.payment.ik))
+      return;
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["events", index, "payment", "ik"],
+      message: `Scene '${scene.name}' has an event for simulated payment '${event.payment.ik}', which it does not declare in \`payments\`.`
+    });
+  });
 });
 var Schema = z.object({
   name: z.string().optional(),
@@ -8148,6 +8319,16 @@ var Schema = z.object({
       path
     })
   );
+  validateReservedPaymentEntryTypes({
+    ledgerEntryTypes: ledgerEntries?.types ?? [],
+    paymentTypes: payments?.types ?? []
+  }).map((e2) => ({ ...e2, path: ["ledgerEntries", ...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(
@@ -8165,56 +8346,20 @@ var Schema = z.object({
       );
     });
   }
+  const { accountPathToAccount } = chartOfAccounts;
+  const ledgerEntryTypes = (ledgerEntries?.types ?? []).map(
+    (entry) => enrichJournalEntry({ entry, accountPathToAccount })
+  );
+  const enrichedPayments = payments && {
+    ...payments,
+    types: payments.types.map(
+      (paymentType) => enrichPaymentType({ paymentType, accountPathToAccount })
+    )
+  };
   return {
     ...schema,
-    ledgerEntries: {
-      types: ledgerEntries?.types.map((entry) => {
-        const lines = entry.lines?.map(
-          (line) => parameterizeSchemaLedgerLineInput({
-            line,
-            entryParameters: entry.parameters
-          })
-        ).map((line) => {
-          const accountPath = line.account.path;
-          const structuralPath = getStructuralPath(accountPath);
-          const fullParameterizedAccount = chartOfAccounts.accountPathToAccount.get(structuralPath);
-          const account = (
-            // TODO: this makes Steven and Jerry very sad, lets fix it later.
-            fullParameterizedAccount && reparameterizeSchemaLedgerAccountInput({
-              account: fullParameterizedAccount,
-              entryParameters: entry.parameters
-            })
-          );
-          const currency = line.currency || account?.currency || { code: "USD" };
-          return {
-            ...line,
-            parameters: line.parameters.concat(
-              account ? account.parameters : []
-            ),
-            // INC-62: We need to use the user-provided path for the account.
-            //         Do not assign it to account.path as it's a shared object
-            //         across entries.
-            account: {
-              ...account,
-              path: accountPath
-            },
-            accountPath,
-            currency
-          };
-        });
-        const conditions = entry.conditions?.map(
-          (condition) => parameterizeSchemaLedgerEntryConditionInput({
-            condition,
-            entryParameters: entry.parameters
-          })
-        );
-        return {
-          ...entry,
-          conditions,
-          lines
-        };
-      }) ?? []
-    },
+    ledgerEntries: { types: ledgerEntryTypes },
+    payments: enrichedPayments,
     consistencyConfig: consistencyConfig ?? {
       entries: "eventual"
     }