@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-status-75W2S3YB.mjs

@@ -0,0 +1,138 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import "./flow-weaver-chunk-I4APCXYN.mjs";
+import "./flow-weaver-chunk-3ZLMPQTH.mjs";
+import "./flow-weaver-chunk-7ET6N32V.mjs";
+import "./flow-weaver-chunk-MMV2XGD3.mjs";
+import "./flow-weaver-chunk-NQKKWDGF.mjs";
+import "./flow-weaver-chunk-V6DHWFQG.mjs";
+import "./flow-weaver-chunk-4DVY73ML.mjs";
+import "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import {
+  validator
+} from "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/status.ts
+import * as fs from "fs";
+import * as path from "path";
+function formatPortList(ports) {
+  return Object.entries(ports).filter(([name]) => name !== "execute" && name !== "onSuccess" && name !== "onFailure").map(([name, port]) => `${name}(${port.dataType.toLowerCase()})`);
+}
+async function statusCommand(input, options = {}) {
+  const { workflowName, json = false } = options;
+  try {
+    const filePath = path.resolve(input);
+    if (!fs.existsSync(filePath)) {
+      if (json) {
+        console.log(JSON.stringify({ error: `File not found: ${input}` }));
+      } else {
+        logger.error(`File not found: ${input}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const parseResult = await parseWorkflow(filePath, { workflowName });
+    if (parseResult.errors.length > 0) {
+      if (json) {
+        console.log(JSON.stringify({ error: `Parse errors: ${parseResult.errors.join(", ")}` }));
+      } else {
+        logger.error("Parse errors:");
+        parseResult.errors.forEach((e) => logger.error(`  ${e}`));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const ast = parseResult.ast;
+    const instanceTypeMap = /* @__PURE__ */ new Map();
+    for (const nt of ast.nodeTypes) {
+      instanceTypeMap.set(nt.name, nt);
+      if (nt.functionName !== nt.name) {
+        instanceTypeMap.set(nt.functionName, nt);
+      }
+    }
+    const nodes = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const instance of ast.instances) {
+      const nt = instanceTypeMap.get(instance.nodeType);
+      if (!nt || seen.has(nt.functionName)) continue;
+      seen.add(nt.functionName);
+      nodes.push({
+        name: nt.functionName,
+        status: nt.variant === "STUB" ? "STUB" : "OK",
+        inputs: formatPortList(nt.inputs),
+        outputs: formatPortList(nt.outputs)
+      });
+    }
+    const implemented = nodes.filter((n) => n.status === "OK").length;
+    const total = nodes.length;
+    const validation = validator.validate(ast, { mode: "draft" });
+    const structuralErrors = validation.errors.filter((e) => e.code !== "STUB_NODE").map((e) => e.message);
+    const result = {
+      name: ast.name,
+      implemented,
+      total,
+      nodes,
+      structurallyValid: structuralErrors.length === 0,
+      structuralErrors
+    };
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      logger.section(`${ast.name}: ${implemented}/${total} nodes implemented`);
+      logger.newline();
+      const maxNameLen = Math.max(...nodes.map((n) => n.name.length), 0);
+      for (const node of nodes) {
+        const tag = node.status === "STUB" ? "[STUB]" : "[OK]  ";
+        const paddedName = node.name.padEnd(maxNameLen);
+        const inputStr = node.inputs.length > 0 ? `inputs: ${node.inputs.join(", ")}` : "";
+        const outputStr = node.outputs.length > 0 ? `outputs: ${node.outputs.join(", ")}` : "";
+        const arrow = inputStr && outputStr ? " \u2192 " : "";
+        const portsStr = `${inputStr}${arrow}${outputStr}`;
+        if (node.status === "STUB") {
+          logger.warn(`  ${paddedName}  ${tag}  ${portsStr}`);
+        } else {
+          logger.success(`  ${paddedName}  ${tag}  ${portsStr}`);
+        }
+      }
+      if (structuralErrors.length > 0) {
+        logger.newline();
+        logger.error(`Structural errors (${structuralErrors.length}):`);
+        structuralErrors.forEach((e) => logger.error(`  - ${e}`));
+      } else {
+        logger.newline();
+        logger.success("Graph structure is valid.");
+      }
+    }
+  } catch (error) {
+    if (json) {
+      console.log(JSON.stringify({ error: getErrorMessage(error) }));
+    } else {
+      logger.error(`Status failed: ${getErrorMessage(error)}`);
+    }
+    process.exitCode = 1;
+  }
+}
+export {
+  statusCommand
+};

package/dist/cli/flow-weaver-strip-AZPXUYVA.mjs

@@ -0,0 +1,79 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  safeWriteFile
+} from "./flow-weaver-chunk-NYZDQYFU.mjs";
+import "./flow-weaver-chunk-A6M5K3W7.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import {
+  hasInPlaceMarkers,
+  stripGeneratedSections
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import {
+  Ze
+} from "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/strip.ts
+import * as fs from "fs";
+import * as path from "path";
+async function stripCommand(input, options = {}) {
+  const { output, dryRun = false, verbose = false } = options;
+  let pattern = input;
+  try {
+    if (fs.existsSync(input) && fs.statSync(input).isDirectory()) {
+      pattern = path.join(input, "**/*.ts");
+    }
+  } catch {
+  }
+  const allFiles = await Ze(pattern, { absolute: true });
+  const files = allFiles.filter((f) => {
+    try {
+      return fs.statSync(f).isFile();
+    } catch {
+      return false;
+    }
+  });
+  if (files.length === 0) {
+    throw new Error(`No files found matching pattern: ${input}`);
+  }
+  const t = logger.timer();
+  let stripped = 0;
+  let skipped = 0;
+  for (const filePath of files) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    if (!hasInPlaceMarkers(content)) {
+      skipped++;
+      if (verbose) {
+        logger.info(`Skipped (no markers): ${path.relative(process.cwd(), filePath)}`);
+      }
+      continue;
+    }
+    const result = stripGeneratedSections(content);
+    if (dryRun) {
+      logger.info(`Would strip: ${path.relative(process.cwd(), filePath)}`);
+      stripped++;
+      continue;
+    }
+    const outPath = output ? path.join(path.resolve(output), path.basename(filePath)) : filePath;
+    safeWriteFile(outPath, result);
+    stripped++;
+    if (verbose) {
+      logger.success(`Stripped: ${path.relative(process.cwd(), outPath)}`);
+    }
+  }
+  const verb = dryRun ? "would be stripped" : "stripped";
+  logger.success(`${stripped} file${stripped !== 1 ? "s" : ""} ${verb}, ${skipped} skipped in ${t.elapsed()}`);
+}
+export {
+  stripCommand
+};

package/dist/cli/flow-weaver-templates-DSNMB6K7.mjs

@@ -0,0 +1,72 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  loadPackTemplates
+} from "./flow-weaver-chunk-QOPRVDES.mjs";
+import {
+  getAllWorkflowTemplates,
+  nodeTemplates
+} from "./flow-weaver-chunk-MMV2XGD3.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/templates.ts
+async function templatesCommand(options = {}) {
+  const { json = false } = options;
+  await loadPackTemplates(process.cwd());
+  const allWorkflowTemplates = getAllWorkflowTemplates();
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          workflows: allWorkflowTemplates.map((t) => ({
+            id: t.id,
+            name: t.name,
+            description: t.description,
+            category: t.category
+          })),
+          nodes: nodeTemplates.map((t) => ({
+            id: t.id,
+            name: t.name,
+            description: t.description
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  logger.section("Workflow Templates");
+  logger.newline();
+  const categories = /* @__PURE__ */ new Map();
+  for (const template of allWorkflowTemplates) {
+    const cat = template.category;
+    if (!categories.has(cat)) {
+      categories.set(cat, []);
+    }
+    categories.get(cat).push(template);
+  }
+  for (const [category, templates] of categories) {
+    logger.info(`  ${category}:`);
+    for (const t of templates) {
+      logger.log(`    ${t.id.padEnd(15)} ${t.description}`);
+    }
+    logger.newline();
+  }
+  logger.section("Node Templates");
+  logger.newline();
+  for (const t of nodeTemplates) {
+    logger.log(`  ${t.id.padEnd(15)} ${t.description}`);
+  }
+  logger.newline();
+  logger.section("Usage");
+  logger.log("  $ fw create workflow <template> <file> [--async] [--line N]");
+  logger.log("  $ fw create node <name> <file> [-t <template>] [--line N]");
+  logger.newline();
+}
+export {
+  templatesCommand
+};

package/dist/cli/flow-weaver-validate-A4UWDQN6.mjs

@@ -0,0 +1,19 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  validateWorkflow
+} from "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+export {
+  validateWorkflow
+};

package/dist/cli/flow-weaver-validate-GRBZ5W4C.mjs

@@ -0,0 +1,296 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  getFriendlyError
+} from "./flow-weaver-chunk-S63Q3JIU.mjs";
+import "./flow-weaver-chunk-I4APCXYN.mjs";
+import "./flow-weaver-chunk-3ZLMPQTH.mjs";
+import "./flow-weaver-chunk-7ET6N32V.mjs";
+import "./flow-weaver-chunk-MMV2XGD3.mjs";
+import "./flow-weaver-chunk-NQKKWDGF.mjs";
+import "./flow-weaver-chunk-V6DHWFQG.mjs";
+import "./flow-weaver-chunk-4DVY73ML.mjs";
+import {
+  validateWorkflow
+} from "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  isMultipleWorkflows,
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import {
+  Ze
+} from "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/validate.ts
+import * as fs from "fs";
+import * as path from "path";
+async function validateCommand(input, options = {}) {
+  const { verbose = false, quiet = false, workflowName, json = false, strict = false } = options;
+  try {
+    let pattern = input;
+    try {
+      if (fs.existsSync(input) && fs.statSync(input).isDirectory()) {
+        pattern = path.join(input, "**/*.ts");
+      }
+    } catch {
+    }
+    const allFiles = await Ze(pattern, { absolute: true });
+    const files = allFiles.filter((f) => {
+      try {
+        return fs.statSync(f).isFile();
+      } catch {
+        return false;
+      }
+    });
+    if (files.length === 0) {
+      if (json) {
+        console.log(JSON.stringify({ error: `No files found matching pattern: ${input}` }));
+        process.exitCode = 1;
+        return;
+      }
+      throw new Error(`No files found matching pattern: ${input}`);
+    }
+    const totalTimer = logger.timer();
+    if (!json) {
+      logger.section("Validating Workflows");
+      if (verbose) {
+        logger.info(`Found ${files.length} file(s)`);
+        logger.newline();
+      }
+    }
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    let successCount = 0;
+    const invalidFiles = /* @__PURE__ */ new Set();
+    const checkedFiles = /* @__PURE__ */ new Set();
+    const jsonResults = [];
+    const targets = files.map((file) => ({ file, workflow: workflowName }));
+    for (let i = 0; i < targets.length; i++) {
+      const { file, workflow } = targets[i];
+      const fileName = workflow && !workflowName ? `${path.basename(file)} (${workflow})` : path.basename(file);
+      if (!json && verbose) {
+        logger.progress(i + 1, targets.length, fileName);
+      }
+      try {
+        const parseResult = await parseWorkflow(file, { workflowName: workflow, projectDir: path.dirname(path.resolve(file)) });
+        if (!workflow && isMultipleWorkflows(parseResult.errors) && parseResult.availableWorkflows.length > 1) {
+          targets.splice(i + 1, 0, ...parseResult.availableWorkflows.map((name) => ({ file, workflow: name })));
+          continue;
+        }
+        if (parseResult.warnings.length > 0) {
+          if (!json && !quiet) {
+            logger.warn(`Parse warnings in ${fileName}:`);
+            parseResult.warnings.forEach((w) => logger.warn(`  - ${w}`));
+          }
+          totalWarnings += parseResult.warnings.length;
+        }
+        if (parseResult.errors.length > 0) {
+          const isNonWorkflowFile = parseResult.errors.length === 1 && typeof parseResult.errors[0] === "string" && parseResult.errors[0].startsWith("No workflows found");
+          if (isNonWorkflowFile) {
+            if (verbose && !json) {
+              logger.debug(`  Skipped ${fileName} (no workflow)`);
+            }
+            continue;
+          }
+          if (json) {
+            jsonResults.push({
+              file,
+              valid: false,
+              errors: parseResult.errors.map(
+                (e) => typeof e === "string" ? { message: e, severity: "error" } : e
+              ),
+              warnings: parseResult.warnings.map(
+                (w) => typeof w === "string" ? { message: w, severity: "warning" } : w
+              )
+            });
+          } else {
+            logger.error(`Parse errors in ${fileName}:`);
+            parseResult.errors.forEach((err) => logger.error(`  ${err}`));
+          }
+          checkedFiles.add(file);
+          invalidFiles.add(file);
+          totalErrors += parseResult.errors.length;
+          continue;
+        }
+        const validation = validateWorkflow(parseResult.ast, strict ? { mode: "strict" } : void 0);
+        if (json) {
+          jsonResults.push({
+            file,
+            ...workflow && !workflowName && { workflow },
+            valid: validation.valid,
+            errors: validation.errors.map((e) => ({
+              message: e.message,
+              severity: e.type || "error",
+              ...e.node && { nodeId: e.node },
+              ...e.code && { code: e.code },
+              ...e.location && { location: e.location },
+              ...e.docUrl && { docUrl: e.docUrl }
+            })),
+            warnings: [
+              ...parseResult.warnings.map(
+                (w) => typeof w === "string" ? { message: w, severity: "warning" } : w
+              ),
+              ...validation.warnings.map((w) => ({
+                message: w.message,
+                severity: w.type || "warning",
+                ...w.node && { nodeId: w.node },
+                ...w.code && { code: w.code },
+                ...w.location && { location: w.location },
+                ...w.docUrl && { docUrl: w.docUrl }
+              }))
+            ]
+          });
+        }
+        if (validation.errors.length > 0) {
+          if (!json) {
+            logger.error(`Validation errors in ${fileName}:`);
+            validation.errors.forEach((err) => {
+              const friendly = getFriendlyError(err);
+              if (friendly) {
+                const loc = err.location ? `[line ${err.location.line}] ` : "";
+                logger.error(`  ${loc}${friendly.title}: ${friendly.explanation}`);
+                logger.warn(`    How to fix: ${friendly.fix}`);
+                if (err.docUrl) {
+                  logger.warn(`    See: ${err.docUrl}`);
+                }
+              } else {
+                let msg = `  - ${err.message}`;
+                if (err.location) {
+                  msg = `  [line ${err.location.line}] - ${err.message}`;
+                }
+                if (err.node) {
+                  msg += ` (node: ${err.node})`;
+                }
+                if (err.connection) {
+                  msg += ` (connection: ${err.connection.from.node}:${err.connection.from.port} -> ${err.connection.to.node}:${err.connection.to.port})`;
+                }
+                logger.error(msg);
+                if (err.docUrl) {
+                  logger.warn(`    See: ${err.docUrl}`);
+                }
+              }
+            });
+          }
+          totalErrors += validation.errors.length;
+        }
+        if (validation.warnings.length > 0) {
+          if (!json && !quiet) {
+            logger.warn(`Warnings in ${fileName}:`);
+            validation.warnings.forEach((warn) => {
+              const friendly = getFriendlyError(warn);
+              if (friendly) {
+                const loc = warn.location ? `[line ${warn.location.line}] ` : "";
+                logger.warn(`  ${loc}${friendly.title}: ${friendly.explanation}`);
+                logger.warn(`    How to fix: ${friendly.fix}`);
+                if (warn.docUrl) {
+                  logger.warn(`    See: ${warn.docUrl}`);
+                }
+              } else {
+                let msg = `  - ${warn.message}`;
+                if (warn.location) {
+                  msg = `  [line ${warn.location.line}] - ${warn.message}`;
+                }
+                if (warn.node) {
+                  msg += ` (node: ${warn.node})`;
+                }
+                logger.warn(msg);
+                if (warn.docUrl) {
+                  logger.warn(`    See: ${warn.docUrl}`);
+                }
+              }
+            });
+          }
+          totalWarnings += validation.warnings.length;
+        }
+        checkedFiles.add(file);
+        if (validation.valid) {
+          if (!json && verbose) {
+            logger.success(`  ${fileName} is valid`);
+          }
+          successCount++;
+        } else {
+          invalidFiles.add(file);
+        }
+      } catch (error) {
+        if (json) {
+          jsonResults.push({
+            file,
+            ...workflow && !workflowName && { workflow },
+            valid: false,
+            errors: [{ message: getErrorMessage(error), severity: "error" }],
+            warnings: []
+          });
+        } else {
+          logger.error(`Failed to validate ${fileName}: ${getErrorMessage(error)}`);
+        }
+        checkedFiles.add(file);
+        invalidFiles.add(file);
+        totalErrors++;
+      }
+    }
+    if (json) {
+      console.log(
+        JSON.stringify(
+          {
+            valid: totalErrors === 0,
+            totalFiles: files.length,
+            validFiles: [...checkedFiles].filter((f) => !invalidFiles.has(f)).length,
+            totalErrors,
+            totalWarnings,
+            results: jsonResults
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      const elapsed = totalTimer.elapsed();
+      logger.newline();
+      if (totalErrors > 0) {
+        const parts = [`${successCount} valid`, `${totalErrors} error${totalErrors !== 1 ? "s" : ""}`];
+        if (totalWarnings > 0) parts.push(`${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}`);
+        logger.log(`  ${parts.join(", ")} in ${elapsed}`);
+      } else if (totalWarnings > 0) {
+        logger.log(`  ${successCount} valid, ${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""} in ${elapsed}`);
+      } else {
+        const unit = targets.length > files.length ? "workflow" : "file";
+        logger.success(`${successCount} ${unit}${successCount !== 1 ? "s" : ""} valid in ${elapsed}`);
+      }
+    }
+    if (totalErrors > 0) {
+      if (json) {
+        process.exitCode = 1;
+        return;
+      }
+      throw new Error(`Validation failed with ${totalErrors} error${totalErrors !== 1 ? "s" : ""}`);
+    }
+  } catch (error) {
+    if (json) {
+      console.log(JSON.stringify({ error: getErrorMessage(error) }));
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+}
+export {
+  validateCommand
+};

package/dist/cli/flow-weaver-validation-registry-BINGUNXX.mjs

@@ -0,0 +1,9 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  validationRuleRegistry
+} from "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+export {
+  validationRuleRegistry
+};

package/dist/cli/flow-weaver-validator-TY56CI42.mjs

@@ -0,0 +1,21 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  validatePackage
+} from "./flow-weaver-chunk-2C7PZCV5.mjs";
+import "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+export {
+  validatePackage
+};