@fragment-dev/cli 2025.9.16 → 2025.9.18

package/dist/{chunk-TQRNHCRL.js → chunk-2L2ZCHD7.js}

@@ -3,7 +3,7 @@ import {
   getInstanceValueByAccountPath,
   getSchemaObjectParameters,
   getStructuralPath
-} from "./chunk-MZOZSRIG.js";
+} from "./chunk-C3HNQQDL.js";
 import {
   BadRequestError,
   CurrencyMatchInputSchema,
@@ -18,7 +18,7 @@ import {
   assert_default,
   currencyCodes,
   safe
-} from "./chunk-SVOY3WJA.js";
+} from "./chunk-YWVJMLFY.js";
 import {
   z
 } from "./chunk-5TQBOAE7.js";
@@ -4621,9 +4621,9 @@ var FlowKey = z.object({
 var SchemaLedgerFlowInput = z.object({
   type: SafeStringSchema,
   typeVersion: z.number().int().positive(),
-  description: z.string().optional(),
+  description: ParameterizedString.optional(),
   clearingAccountPath: ParameterizedString,
-  initializingEntry: BaseSchemaLedgerEntryInput,
+  initializingEntry: FlowKey,
   entries: z.array(FlowKey),
   flows: z.array(FlowKey)
 });
@@ -5522,6 +5522,93 @@ var getStructuralPathToAccount = (validatedCoA) => {
   validatedCoA.accounts.forEach((account) => walk(account));
   return accountPathToAccount;
 };
+var validateAccountPathExists = (accountPath, accountPathToAccount, context, path) => {
+  const structuralPath = getStructuralPath(accountPath);
+  const account = accountPathToAccount.get(structuralPath);
+  if (!account) {
+    return [
+      {
+        message: `${context} refers to a non-existent account path: ${accountPath}`,
+        path
+      }
+    ];
+  }
+  return [];
+};
+var validateAccountPathFormat = (accountPath, context, path) => {
+  if (accountPath.includes("#")) {
+    return [
+      {
+        message: `${context} account path '${accountPath}' cannot contain '#'`,
+        path
+      }
+    ];
+  }
+  return [];
+};
+var validateAccountPathNotEmpty = (accountPath, context, path) => {
+  if (!accountPath || accountPath.trim() === "") {
+    return [
+      {
+        message: `${context} must specify an account path`,
+        path
+      }
+    ];
+  }
+  return [];
+};
+var validateAccountPath = (accountPath, accountPathToAccount, context, path) => {
+  const errors = [];
+  errors.push(...validateAccountPathNotEmpty(accountPath, context, path));
+  if (errors.length > 0) {
+    return errors;
+  }
+  errors.push(...validateAccountPathFormat(accountPath, context, path));
+  errors.push(
+    ...validateAccountPathExists(
+      accountPath,
+      accountPathToAccount,
+      context,
+      path
+    )
+  );
+  return errors;
+};
+var validateAccountIsActive = (accountPath, accountPathToAccount, context, path) => {
+  const structuralPath = getStructuralPath(accountPath);
+  const account = accountPathToAccount.get(structuralPath);
+  if (!account) {
+    return [];
+  }
+  const accountStatus = getAccountStatus(account);
+  if (accountStatus !== "active") {
+    return [
+      {
+        message: `${context} refers to an account with status '${account.status}'. Only active accounts can be used.`,
+        path
+      }
+    ];
+  }
+  return [];
+};
+var validateTemplateAccountParameters = (accountPath, accountPathToAccount, context, path) => {
+  const instanceValueMap = getInstanceValueByAccountPath(accountPath);
+  const errors = [];
+  Array.from(instanceValueMap.keys()).forEach((ancestorPath) => {
+    const structuralAncestorPath = getStructuralPath(ancestorPath);
+    const ancestor = accountPathToAccount.get(structuralAncestorPath);
+    if (!ancestor) {
+      return;
+    }
+    if (ancestor.template && !instanceValueMap.get(ancestorPath)) {
+      errors.push({
+        message: `Invalid account path for ${context.toLowerCase()}. This ${context.toLowerCase()} refers to a Template Account, but is missing a variable that identifies the instance of the Template Account. For example: ${ancestorPath}:{{var}}`,
+        path
+      });
+    }
+  });
+  return errors;
+};
 
 // ../../libs/schema-validation/utils/transformers/entries.ts
 var validateNonEmptySafeString = ({
@@ -6231,6 +6318,209 @@ var transformAndValidateEntries = ({
   };
 };
 
+// ../../libs/schema-validation/utils/transformers/flows.ts
+init_cjs_shims();
+var isAccountPathEquivalent = (path1, path2) => {
+  return getStructuralPath(path1) === getStructuralPath(path2);
+};
+var validateMinimumSteps = (flow) => {
+  const stepCount = flow.entries.length + (flow.flows?.length ?? 0);
+  if (stepCount < 2) {
+    return [
+      {
+        message: "Flow must have at least 2 elements (entries or flows)",
+        path: []
+      }
+    ];
+  }
+  return [];
+};
+var validateInitializingEntryExists = (flow, validatedEntries) => {
+  const initializingEntry = validatedEntries.types.find(
+    (e) => e.type === flow.initializingEntry.type && (e.typeVersion ?? 1) === flow.initializingEntry.typeVersion
+  );
+  if (!initializingEntry) {
+    return [
+      {
+        message: "Flow must have an initializing entry",
+        path: ["initializingEntry"]
+      }
+    ];
+  }
+  return [];
+};
+var validateUniqueEntries = (flow) => {
+  const entrySet = new Set(
+    flow.entries.map((entry) => `${entry.type}:${entry.typeVersion}`)
+  );
+  if (entrySet.size !== flow.entries.length) {
+    return [
+      {
+        message: "Cannot have duplicate entries in the flow",
+        path: ["entries"]
+      }
+    ];
+  }
+  return [];
+};
+var validateUniqueFlows = (flow) => {
+  const flowSet = new Set(flow.flows.map((f) => `${f.type}:${f.typeVersion}`));
+  if (flowSet.size !== flow.flows.length) {
+    return [
+      { message: "Cannot have duplicate flows in the flow", path: ["flows"] }
+    ];
+  }
+  return [];
+};
+var validateEntriesModifyClearingAccount = (flow, validatedEntries) => {
+  const clearingAccount = flow.clearingAccountPath;
+  const fullEntries = flow.entries.map((entry) => {
+    const fullEntry = validatedEntries.types.find(
+      (e) => e.type === entry.type && (e.typeVersion ?? 1) === entry.typeVersion
+    );
+    return fullEntry;
+  });
+  if (fullEntries.length !== flow.entries.length) {
+    return [
+      {
+        message: "All entries in the flow must be present in the validated entries",
+        path: ["entries"]
+      }
+    ];
+  }
+  const entriesMissingClearingAccount = fullEntries.filter(
+    (e) => !e?.lines?.some(
+      (l) => isAccountPathEquivalent(l.account.path, clearingAccount)
+    )
+  );
+  if (entriesMissingClearingAccount.length > 0) {
+    return entriesMissingClearingAccount.map((e) => ({
+      message: `All entries in the flow must modify the clearing account, not present in the entries ${e?.type} v${e?.typeVersion}`,
+      path: ["entries"]
+    }));
+  }
+  return [];
+};
+var validateFlowsDepthAndCircularity = (flow, flows) => {
+  if (!flows || !flow.flows || flow.flows.length === 0) {
+    return [];
+  }
+  const errors = [];
+  const visited = /* @__PURE__ */ new Set();
+  const currentPath = [];
+  const validateFlowRecursively = (currentFlow, depth, path) => {
+    const flowId = `${currentFlow.type}:${currentFlow.typeVersion}`;
+    if (visited.has(flowId)) {
+      if (currentPath.includes(flowId)) {
+        errors.push({
+          message: `Circular reference detected in flow: ${flowId}`,
+          path: ["flows", ...path]
+        });
+        return;
+      }
+      return;
+    }
+    if (depth > 5) {
+      errors.push({
+        message: `Flow depth exceeds maximum of 5 levels: ${flowId}`,
+        path: ["flows", ...path]
+      });
+      return;
+    }
+    visited.add(flowId);
+    currentPath.push(flowId);
+    if (currentFlow.flows && currentFlow.flows.length > 0) {
+      currentFlow.flows.forEach((flowKey, index) => {
+        const childFlowId = `${flowKey.type}:${flowKey.typeVersion}`;
+        const childFlow = flows.find(
+          (f) => f.type === flowKey.type && f.typeVersion === flowKey.typeVersion
+        );
+        if (childFlow) {
+          validateFlowRecursively(childFlow, depth + 1, [
+            ...path,
+            index.toString()
+          ]);
+        } else {
+          errors.push({
+            message: `Referenced flow not found: ${childFlowId}`,
+            path: ["flows", ...path, index.toString()]
+          });
+        }
+      });
+    }
+    currentPath.pop();
+  };
+  validateFlowRecursively(flow, 0, []);
+  return errors;
+};
+var validateFlowEntryReferences = (flow, validatedEntries) => {
+  const errors = [];
+  flow.entries.forEach((entryRef, index) => {
+    const matchingEntry = validatedEntries?.types?.find(
+      (entry) => entry.type === entryRef.type && (entry.typeVersion ?? 1) === entryRef.typeVersion
+    );
+    if (!matchingEntry) {
+      errors.push({
+        message: `Flow entry not found in validated entries: ${entryRef.type}:${entryRef.typeVersion}`,
+        path: ["entries", index]
+      });
+    } else {
+    }
+  });
+  return errors;
+};
+var validateClearingAccount = (flow, validatedCoA) => {
+  const clearingAccount = flow.clearingAccountPath;
+  const accountPathToAccount = getStructuralPathToAccount(validatedCoA);
+  const errors = [];
+  errors.push(
+    ...validateAccountPath(
+      clearingAccount,
+      accountPathToAccount,
+      "Flow clearing account",
+      ["clearingAccountPath"]
+    )
+  );
+  errors.push(
+    ...validateAccountIsActive(
+      clearingAccount,
+      accountPathToAccount,
+      "Flow clearing account",
+      ["clearingAccountPath"]
+    )
+  );
+  errors.push(
+    ...validateTemplateAccountParameters(
+      clearingAccount,
+      accountPathToAccount,
+      "Flow clearing account",
+      ["clearingAccountPath"]
+    )
+  );
+  return errors;
+};
+var validateFlow = (flow, validatedCoA, validatedEntries, flows) => {
+  const errors = [];
+  const zodErrors = safeGetZodErrors(SchemaLedgerFlowInput, flow, []);
+  errors.push(...zodErrors);
+  if (errors.length > 0) {
+    return errors;
+  }
+  errors.push(...validateMinimumSteps(flow));
+  errors.push(...validateInitializingEntryExists(flow, validatedEntries));
+  errors.push(...validateUniqueEntries(flow));
+  errors.push(...validateUniqueFlows(flow));
+  if (errors.length === 0) {
+    errors.push(...validateFlowEntryReferences(flow, validatedEntries));
+    errors.push(...validateFlowsDepthAndCircularity(flow, flows));
+    errors.push(...validateClearingAccount(flow, validatedCoA));
+    errors.push(
+      ...validateEntriesModifyClearingAccount(flow, validatedEntries)
+    );
+  }
+  return errors;
+};
+
 // ../../libs/schema-validation/types.ts
 var SchemaCurrencyMatchInput2 = z.object({
   customCurrencyId: ParameterizedString.optional(),
@@ -6464,10 +6754,11 @@ var Schema = z.object({
   chartOfAccounts: ChartOfAccounts,
   ledgerEntries: SchemaLedgerEntriesInput.optional(),
   consistencyConfig: z.optional(LedgerConsistencyConfigSchema),
-  scenes: z.array(Scene).optional()
+  scenes: z.array(Scene).optional(),
+  flows: z.array(SchemaLedgerFlowInput).optional()
 }).transform((schema, ctx) => {
-  const { chartOfAccounts, ledgerEntries, consistencyConfig } = schema;
-  const { errors } = transformAndValidateEntries({
+  const { chartOfAccounts, ledgerEntries, consistencyConfig, flows } = schema;
+  const { errors, filledIn: validatedLedgerEntries } = transformAndValidateEntries({
     ledgerEntries: ledgerEntries ?? { types: [] },
     validatedCoA: chartOfAccounts
   });
@@ -6478,6 +6769,23 @@ var Schema = z.object({
       path
     })
   );
+  if (flows && flows.length > 0) {
+    flows.forEach((flow, index) => {
+      const flowErrors = validateFlow(
+        flow,
+        chartOfAccounts,
+        validatedLedgerEntries,
+        flows
+      );
+      flowErrors.forEach(
+        ({ message, path }) => ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message,
+          path: ["flows", index, ...path]
+        })
+      );
+    });
+  }
   return {
     ...schema,
     ledgerEntries: {

package/dist/{chunk-5NNGFUR2.js → chunk-2YDYMQEU.js}

@@ -3,22 +3,22 @@ import {
   generateQueryFiles,
   schemaToEntryDefinitions,
   validateOutputName
-} from "./chunk-3UMWAIEH.js";
+} from "./chunk-WVPWSZFV.js";
 import {
   Schema,
   parseWithError
-} from "./chunk-TQRNHCRL.js";
+} from "./chunk-2L2ZCHD7.js";
 import {
   formatValidationErrors,
   logValidationErrors
-} from "./chunk-GX2Y7J77.js";
+} from "./chunk-EUDPQTGG.js";
 import {
   BadRequestError
-} from "./chunk-SVOY3WJA.js";
+} from "./chunk-YWVJMLFY.js";
 import {
   FragmentCommand,
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   getParsedSchema
 } from "./chunk-UDU5PBTV.js";

package/dist/{chunk-TRKCW3NY.js → chunk-3BFX3ZQM.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   getParsedSchema
 } from "./chunk-UDU5PBTV.js";

package/dist/{chunk-QBIZ7TKK.js → chunk-3LSL4JNW.js}

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

package/dist/{chunk-SHWFFRUQ.js → chunk-5YFHCTKF.js}

@@ -1,13 +1,13 @@
 import {
   Schema,
   parseWithError
-} from "./chunk-TQRNHCRL.js";
+} from "./chunk-2L2ZCHD7.js";
 import {
   formatValidationErrors
-} from "./chunk-GX2Y7J77.js";
+} from "./chunk-EUDPQTGG.js";
 import {
   BadRequestError
-} from "./chunk-SVOY3WJA.js";
+} from "./chunk-YWVJMLFY.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

package/dist/{chunk-WIRNGK2K.js → chunk-65EPGXM5.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   getParsedSchema
 } from "./chunk-UDU5PBTV.js";

package/dist/{chunk-VSZ6RUPS.js → chunk-6Z6OR4JK.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   require_source
 } from "./chunk-M5OAS5QZ.js";

package/dist/{chunk-2HFDOCFT.js → chunk-BQJEXZ3Z.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   require_source
 } from "./chunk-M5OAS5QZ.js";

package/dist/{chunk-MZOZSRIG.js → chunk-C3HNQQDL.js}

@@ -3,7 +3,7 @@ import {
   assert_default,
   codes,
   getStringParametersInternal
-} from "./chunk-SVOY3WJA.js";
+} from "./chunk-YWVJMLFY.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

package/dist/{chunk-AB5MEBC5.js → chunk-DPINR45T.js}

@@ -1,72 +1,72 @@
 import {
   ReverseLedgerEntry
-} from "./chunk-S2W7I2OB.js";
+} from "./chunk-ZDE3DZ3I.js";
 import {
   Start
-} from "./chunk-CQC265GZ.js";
+} from "./chunk-T3TNAOFS.js";
 import {
   StoreSchema
-} from "./chunk-TRKCW3NY.js";
+} from "./chunk-3BFX3ZQM.js";
 import {
   Token
-} from "./chunk-JVTCCEVF.js";
+} from "./chunk-LCVLN3SZ.js";
 import {
   UpdateLedgerAccount
-} from "./chunk-SXU2Z4NO.js";
+} from "./chunk-GRMPAF2X.js";
 import {
   Update
-} from "./chunk-SIANE5YG.js";
+} from "./chunk-HDSQSGJZ.js";
 import {
   VerifySchema
-} from "./chunk-VDFDR5ZV.js";
+} from "./chunk-Z3BY6FHK.js";
 import {
   Workspace
-} from "./chunk-QBIZ7TKK.js";
+} from "./chunk-3LSL4JNW.js";
 import {
   GetSchema
-} from "./chunk-7VJJQFG3.js";
+} from "./chunk-UOIGY3UB.js";
 import {
   Init
-} from "./chunk-2FO2MNL3.js";
+} from "./chunk-GGCDYQIW.js";
 import {
   Login
-} from "./chunk-5LMN5BVB.js";
+} from "./chunk-V25PI4BY.js";
 import {
   MigrateLedgerEntry
-} from "./chunk-VSZ6RUPS.js";
+} from "./chunk-6Z6OR4JK.js";
 import {
   QueryLedgerAccounts
-} from "./chunk-YYLQONCA.js";
+} from "./chunk-HLAM7IYL.js";
 import {
   QueryLedgers
-} from "./chunk-J64IPF3G.js";
+} from "./chunk-IWMNMIA6.js";
 import {
   GetSchema as GetSchema2
-} from "./chunk-J43COUXZ.js";
+} from "./chunk-O5U5EZDT.js";
 import {
   QuerySchemas
-} from "./chunk-YCYDA7QC.js";
+} from "./chunk-LWYIMR7B.js";
 import {
   AddLedgerEntry
-} from "./chunk-2HFDOCFT.js";
+} from "./chunk-BQJEXZ3Z.js";
 import {
   CreateCustomLink
-} from "./chunk-5MGMIUUK.js";
+} from "./chunk-H3DG2EYM.js";
 import {
   CreateLedger
-} from "./chunk-WIRNGK2K.js";
+} from "./chunk-65EPGXM5.js";
 import {
   DeleteCustomTxs
-} from "./chunk-TGCLIO5Q.js";
+} from "./chunk-ZQHWOO25.js";
 import {
   DeleteLedger
-} from "./chunk-GH45O4YP.js";
+} from "./chunk-YGEYBIHA.js";
 import {
   DeleteSchema
-} from "./chunk-EW6ZJJMC.js";
+} from "./chunk-VRHCYGEJ.js";
 import {
   GenGraphQL
-} from "./chunk-5NNGFUR2.js";
+} from "./chunk-2YDYMQEU.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

package/dist/{chunk-GX2Y7J77.js → chunk-EUDPQTGG.js}

@@ -1,6 +1,6 @@
 import {
   BadRequestError
-} from "./chunk-SVOY3WJA.js";
+} from "./chunk-YWVJMLFY.js";
 import {
   ZodError
 } from "./chunk-5TQBOAE7.js";

package/dist/{chunk-2FO2MNL3.js → chunk-GGCDYQIW.js}

@@ -1,7 +1,7 @@
 import {
   FragmentCommand,
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   require_source
 } from "./chunk-M5OAS5QZ.js";

package/dist/{chunk-SXU2Z4NO.js → chunk-GRMPAF2X.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   require_source
 } from "./chunk-M5OAS5QZ.js";

package/dist/{chunk-5MGMIUUK.js → chunk-H3DG2EYM.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   require_source
 } from "./chunk-M5OAS5QZ.js";

package/dist/{chunk-SIANE5YG.js → chunk-HDSQSGJZ.js}

@@ -1,10 +1,10 @@
 import {
   inquirer_default
-} from "./chunk-7D2QXYKM.js";
+} from "./chunk-JEFROCJ4.js";
 import {
   FragmentCommand,
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   require_source
 } from "./chunk-M5OAS5QZ.js";

package/dist/{chunk-YYLQONCA.js → chunk-HLAM7IYL.js}

@@ -1,9 +1,9 @@
 import {
   AuthenticatedCommand
-} from "./chunk-PWYEYSX5.js";
+} from "./chunk-IVDQ4PQW.js";
 import {
   require_lib
-} from "./chunk-EBRMLGNI.js";
+} from "./chunk-IH6BCA6S.js";
 import {
   __toESM,
   init_cjs_shims