@open-mercato/cli 0.4.2-canary-c02407ff85

package/dist/mercato.js

@@ -0,0 +1,1045 @@
+import { createRequestContainer } from "@open-mercato/shared/lib/di/container";
+import { runWorker } from "@open-mercato/queue/worker";
+import { getCliModules, hasCliModules, registerCliModules } from "./registry.js";
+import { parseBooleanToken } from "@open-mercato/shared/lib/boolean";
+import path from "node:path";
+import fs from "node:fs";
+let envLoaded = false;
+async function ensureEnvLoaded() {
+  if (envLoaded) return;
+  envLoaded = true;
+  try {
+    const { createResolver } = await import("./lib/resolver.js");
+    const resolver = createResolver();
+    const appDir = resolver.getAppDir();
+    const envPath = path.join(appDir, ".env");
+    if (fs.existsSync(envPath)) {
+      const dotenv = await import("dotenv");
+      dotenv.config({ path: envPath });
+      return;
+    }
+  } catch {
+  }
+  try {
+    await import("dotenv/config");
+  } catch {
+  }
+}
+async function runModuleCommand(allModules, moduleName, commandName, args = []) {
+  const mod = allModules.find((m) => m.id === moduleName);
+  if (!mod) {
+    throw new Error(`Module not found: "${moduleName}"`);
+  }
+  if (!mod.cli || mod.cli.length === 0) {
+    throw new Error(`Module "${moduleName}" has no CLI commands`);
+  }
+  const cmd = mod.cli.find((c) => c.command === commandName);
+  if (!cmd) {
+    throw new Error(`Command "${commandName}" not found in module "${moduleName}"`);
+  }
+  await cmd.run(args);
+}
+async function buildAllModules() {
+  const modules = getCliModules();
+  let appCli = [];
+  try {
+    const dynImport = Function("return import")();
+    const app = await dynImport.then((f) => f("@/cli")).catch(() => null);
+    if (app && Array.isArray(app?.default)) appCli = app.default;
+  } catch {
+  }
+  const all = modules.slice();
+  if (appCli.length) all.push({ id: "app", cli: appCli });
+  return all;
+}
+async function run(argv = process.argv) {
+  await ensureEnvLoaded();
+  const [, , ...parts] = argv;
+  const [first, second, ...remaining] = parts;
+  if (first === "init") {
+    const { execSync } = await import("child_process");
+    console.log("\u{1F680} Initializing Open Mercato app...\n");
+    try {
+      const initArgs = parts.slice(1).filter(Boolean);
+      const reinstall = initArgs.includes("--reinstall") || initArgs.includes("-r");
+      const skipExamples = initArgs.includes("--no-examples") || initArgs.includes("--no-exampls");
+      const stressTestEnabled = initArgs.includes("--stresstest") || initArgs.includes("--stress-test");
+      const stressTestLite = initArgs.includes("--lite") || initArgs.includes("--stress-lite") || initArgs.some((arg) => arg.startsWith("--payload=lite") || arg.startsWith("--mode=lite"));
+      let stressTestCount = 6e3;
+      for (let i = 0; i < initArgs.length; i += 1) {
+        const arg = initArgs[i];
+        const countPrefixes = ["--count=", "--stress-count=", "--stresstest-count="];
+        const matchedPrefix = countPrefixes.find((prefix) => arg.startsWith(prefix));
+        if (matchedPrefix) {
+          const value = arg.slice(matchedPrefix.length);
+          const parsed = Number.parseInt(value, 10);
+          if (Number.isFinite(parsed) && parsed > 0) {
+            stressTestCount = parsed;
+            break;
+          }
+        }
+        if (arg === "--count" || arg === "--stress-count" || arg === "--stresstest-count" || arg === "-n") {
+          const next = initArgs[i + 1];
+          if (next && !next.startsWith("-")) {
+            const parsed = Number.parseInt(next, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+              stressTestCount = parsed;
+              break;
+            }
+          }
+        }
+        if (arg.startsWith("-n=")) {
+          const value = arg.slice(3);
+          const parsed = Number.parseInt(value, 10);
+          if (Number.isFinite(parsed) && parsed > 0) {
+            stressTestCount = parsed;
+            break;
+          }
+        }
+      }
+      console.log(`\u{1F504} Reinstall mode: ${reinstall ? "enabled" : "disabled"}`);
+      console.log(`\u{1F3A8} Example content: ${skipExamples ? "skipped (--no-examples)" : "enabled"}`);
+      console.log(
+        `\u{1F3CB}\uFE0F Stress test dataset: ${stressTestEnabled ? `enabled (target ${stressTestCount} contacts${stressTestLite ? ", lite payload" : ""})` : "disabled"}`
+      );
+      if (reinstall) {
+        await ensureEnvLoaded();
+        console.log("\u267B\uFE0F  Reinstall mode enabled: dropping all database tables...");
+        const { Client: Client2 } = await import("pg");
+        const dbUrl2 = process.env.DATABASE_URL;
+        if (!dbUrl2) {
+          console.error("DATABASE_URL is not set. Aborting reinstall.");
+          return 1;
+        }
+        const client = new Client2({ connectionString: dbUrl2 });
+        try {
+          await client.connect();
+          const res = await client.query(`SELECT tablename FROM pg_tables WHERE schemaname = 'public'`);
+          const dropTargets = new Set((res.rows || []).map((r) => String(r.tablename)));
+          for (const forced of ["vector_search", "vector_search_migrations"]) {
+            const exists = await client.query(
+              `SELECT to_regclass($1) AS regclass`,
+              [`public.${forced}`]
+            );
+            const regclass = exists.rows?.[0]?.regclass ?? null;
+            if (regclass) {
+              dropTargets.add(forced);
+            }
+          }
+          if (dropTargets.size === 0) {
+            console.log("   No tables found in public schema.");
+          } else {
+            let dropped = 0;
+            await client.query("BEGIN");
+            try {
+              for (const t of dropTargets) {
+                await client.query(`DROP TABLE IF EXISTS "${t}" CASCADE`);
+                dropped += 1;
+              }
+              await client.query("COMMIT");
+              console.log(`   Dropped ${dropped} tables.`);
+            } catch (e) {
+              await client.query("ROLLBACK");
+              throw e;
+            }
+          }
+        } finally {
+          try {
+            await client.end();
+          } catch {
+          }
+        }
+        try {
+          const Redis = (await import("ioredis")).default;
+          const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
+          const redis = new Redis(redisUrl);
+          await redis.flushall();
+          await redis.quit();
+          console.log("   Redis flushed.");
+        } catch {
+        }
+        console.log("\u2705 Database cleared. Proceeding with fresh initialization...\n");
+      }
+      console.log("\u{1F527} Preparing modules (registry, entities, DI)...");
+      const { createResolver } = await import("./lib/resolver.js");
+      const { generateEntityIds, generateModuleRegistry, generateModuleRegistryCli, generateModuleEntities, generateModuleDi } = await import("./lib/generators/index.js");
+      const resolver = createResolver();
+      await generateEntityIds({ resolver, quiet: true });
+      await generateModuleRegistry({ resolver, quiet: true });
+      await generateModuleRegistryCli({ resolver, quiet: true });
+      await generateModuleEntities({ resolver, quiet: true });
+      await generateModuleDi({ resolver, quiet: true });
+      console.log("\u2705 Modules prepared\n");
+      console.log("\u{1F4CA} Applying database migrations...");
+      const { dbMigrate } = await import("./lib/db/index.js");
+      await dbMigrate(resolver);
+      console.log("\u2705 Migrations applied\n");
+      console.log("\u{1F517} Bootstrapping application...");
+      const { bootstrapFromAppRoot } = await import("@open-mercato/shared/lib/bootstrap/dynamicLoader");
+      const bootstrapData = await bootstrapFromAppRoot(resolver.getAppDir());
+      registerCliModules(bootstrapData.modules);
+      console.log("\u2705 Bootstrap complete\n");
+      const allModules = await buildAllModules();
+      console.log("\u2699\uFE0F  Restoring module defaults...");
+      await runModuleCommand(allModules, "configs", "restore-defaults", []);
+      console.log("\u2705 Module defaults restored\n");
+      const findArgValue = (names, fallback) => {
+        for (const name of names) {
+          const match = initArgs.find((arg) => arg.startsWith(name));
+          if (match) {
+            const value = match.slice(name.length);
+            if (value) return value;
+          }
+        }
+        return fallback;
+      };
+      const orgName = findArgValue(["--org=", "--orgName="], "Acme Corp");
+      const email = findArgValue(["--email="], "superadmin@acme.com");
+      const password = findArgValue(["--password="], "secret");
+      const roles = findArgValue(["--roles="], "superadmin,admin,employee");
+      console.log("\u{1F510} Setting up RBAC and users...");
+      await runModuleCommand(allModules, "auth", "setup", [
+        "--orgName",
+        orgName,
+        "--email",
+        email,
+        "--password",
+        password,
+        "--roles",
+        roles
+      ]);
+      const { Client } = await import("pg");
+      const dbUrl = process.env.DATABASE_URL;
+      const pgClient = new Client({ connectionString: dbUrl });
+      await pgClient.connect();
+      const orgResult = await pgClient.query(
+        `SELECT o.id as org_id, o.tenant_id FROM organizations o
+         JOIN users u ON u.organization_id = o.id
+         LIMIT 1`
+      );
+      await pgClient.end();
+      const tenantId = orgResult?.rows?.[0]?.tenant_id ?? null;
+      const orgId = orgResult?.rows?.[0]?.org_id ?? null;
+      console.log("\u2705 RBAC setup complete:", { tenantId, organizationId: orgId }, "\n");
+      console.log("\u{1F39B}\uFE0F  Seeding feature toggle defaults...");
+      await runModuleCommand(allModules, "feature_toggles", "seed-defaults", []);
+      console.log("\u{1F39B}\uFE0F  \u2705 Feature toggle defaults seeded\n");
+      if (tenantId) {
+        console.log("\u{1F465} Seeding tenant-scoped roles...");
+        await runModuleCommand(allModules, "auth", "seed-roles", ["--tenant", tenantId]);
+        console.log("\u{1F6E1}\uFE0F \u2705 Roles seeded\n");
+      } else {
+        console.log("\u26A0\uFE0F  Skipping role seeding because tenant ID was not available.\n");
+      }
+      if (orgId && tenantId) {
+        if (reinstall) {
+          console.log("\u{1F9E9} Reinstalling custom field definitions...");
+          await runModuleCommand(allModules, "entities", "reinstall", ["--tenant", tenantId]);
+          console.log("\u{1F9E9} \u2705 Custom field definitions reinstalled\n");
+        }
+        console.log("\u{1F4DA} Seeding customer dictionaries...");
+        await runModuleCommand(allModules, "customers", "seed-dictionaries", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F4DA} \u2705 Customer dictionaries seeded\n");
+        console.log("\u{1F3E0} Seeding staff address types...");
+        await runModuleCommand(allModules, "staff", "seed-address-types", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F3E0} \u2705 Staff address types seeded\n");
+        console.log("\u{1F3E0} Seeding resources address types...");
+        await runModuleCommand(allModules, "resources", "seed-address-types", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F3E0} \u2705 Resources address types seeded\n");
+        console.log("\u{1F4DA} Seeding currencies...");
+        await runModuleCommand(allModules, "currencies", "seed", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F4DA} \u2705 Currencies seeded\n");
+        console.log("\u{1F4CF} Seeding catalog units...");
+        await runModuleCommand(allModules, "catalog", "seed-units", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F4CF} \u2705 Catalog units seeded\n");
+        console.log("\u{1F5D3}\uFE0F  Seeding unavailability reasons...");
+        await runModuleCommand(allModules, "planner", "seed-unavailability-reasons", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F5D3}\uFE0F  \u2705 Unavailability reasons seeded\n");
+        const parsedEncryption = parseBooleanToken(process.env.TENANT_DATA_ENCRYPTION ?? "yes");
+        const encryptionEnabled = parsedEncryption === null ? true : parsedEncryption;
+        if (encryptionEnabled) {
+          console.log("\u{1F512} Seeding encryption defaults...");
+          await runModuleCommand(allModules, "entities", "seed-encryption", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F512} \u2705 Encryption defaults seeded\n");
+        } else {
+          console.log("\u26A0\uFE0F  TENANT_DATA_ENCRYPTION disabled; skipping encryption defaults.\n");
+        }
+        console.log("\u{1F3F7}\uFE0F  Seeding catalog price kinds...");
+        await runModuleCommand(allModules, "catalog", "seed-price-kinds", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F3F7}\uFE0F \u2705 Catalog price kinds seeded\n");
+        console.log("\u{1F4B6} Seeding default tax rates...");
+        await runModuleCommand(allModules, "sales", "seed-tax-rates", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F9FE} \u2705 Tax rates seeded\n");
+        console.log("\u{1F6A6} Seeding sales statuses...");
+        await runModuleCommand(allModules, "sales", "seed-statuses", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F6A6} \u2705 Sales statuses seeded\n");
+        console.log("\u2699\uFE0F  Seeding adjustment kinds...");
+        await runModuleCommand(allModules, "sales", "seed-adjustment-kinds", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u2699\uFE0F  \u2705 Adjustment kinds seeded\n");
+        console.log("\u{1F69A} Seeding shipping methods...");
+        await runModuleCommand(allModules, "sales", "seed-shipping-methods", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F69A} \u2705 Shipping methods seeded\n");
+        console.log("\u{1F4B3} Seeding payment methods...");
+        await runModuleCommand(allModules, "sales", "seed-payment-methods", ["--tenant", tenantId, "--org", orgId]);
+        console.log("\u{1F4B3} \u2705 Payment methods seeded\n");
+        console.log("\u{1F504} Seeding workflow definitions...");
+        try {
+          await runModuleCommand(allModules, "workflows", "seed-all", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u2705 Workflows and business rules seeded\n");
+        } catch (err) {
+          console.error("\u26A0\uFE0F  Workflow seeding failed (non-fatal):", err);
+        }
+        if (skipExamples) {
+          console.log("\u{1F6AB} Example data seeding skipped (--no-examples)\n");
+        } else {
+          console.log("\u{1F6CD}\uFE0F  Seeding catalog examples...");
+          await runModuleCommand(allModules, "catalog", "seed-examples", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F6CD}\uFE0F \u2705 Catalog examples seeded\n");
+          console.log("\u{1F3E2} Seeding customer examples...");
+          await runModuleCommand(allModules, "customers", "seed-examples", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F3E2} \u2705 Customer examples seeded\n");
+          console.log("\u{1F9FE} Seeding sales examples...");
+          await runModuleCommand(allModules, "sales", "seed-examples", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F9FE} \u2705 Sales examples seeded\n");
+          console.log("\u{1F465} Seeding staff examples...");
+          await runModuleCommand(allModules, "staff", "seed-examples", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F465} \u2705 Staff examples seeded\n");
+          console.log("\u{1F4E6} Seeding resource capacity units...");
+          await runModuleCommand(allModules, "resources", "seed-capacity-units", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F4E6} \u2705 Resource capacity units seeded\n");
+          console.log("\u{1F9F0} Seeding resource examples...");
+          await runModuleCommand(allModules, "resources", "seed-examples", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F9F0} \u2705 Resource examples seeded\n");
+          console.log("\u{1F5D3}\uFE0F  Seeding planner availability rulesets...");
+          await runModuleCommand(allModules, "planner", "seed-availability-rulesets", ["--tenant", tenantId, "--org", orgId]);
+          console.log("\u{1F5D3}\uFE0F  \u2705 Planner availability rulesets seeded\n");
+          const exampleModule = allModules.find((m) => m.id === "example");
+          if (exampleModule && exampleModule.cli) {
+            console.log("\u{1F4DD} Seeding example todos...");
+            await runModuleCommand(allModules, "example", "seed-todos", ["--org", orgId, "--tenant", tenantId]);
+            console.log("\u{1F4DD} \u2705 Example todos seeded\n");
+          }
+        }
+        if (stressTestEnabled) {
+          console.log(
+            `\u{1F3CB}\uFE0F  Seeding stress test customers${stressTestLite ? " (lite payload)" : ""}...`
+          );
+          const stressArgs = ["--tenant", tenantId, "--org", orgId, "--count", String(stressTestCount)];
+          if (stressTestLite) stressArgs.push("--lite");
+          await runModuleCommand(allModules, "customers", "seed-stresstest", stressArgs);
+          console.log(`\u2705 Stress test customers seeded (requested ${stressTestCount})
+`);
+        }
+        console.log("\u{1F9E9} Enabling default dashboard widgets...");
+        await runModuleCommand(allModules, "dashboards", "seed-defaults", ["--tenant", tenantId]);
+        console.log("\u2705 Dashboard widgets enabled\n");
+      } else {
+        console.log("\u26A0\uFE0F  Could not get organization ID or tenant ID, skipping seeding steps\n");
+      }
+      console.log("\u{1F9E0} Building search indexes...");
+      const vectorArgs = tenantId ? ["--tenant", tenantId, ...orgId ? ["--org", orgId] : []] : ["--purgeFirst=false"];
+      await runModuleCommand(allModules, "search", "reindex", vectorArgs);
+      console.log("\u2705 Search indexes built\n");
+      console.log("\u{1F50D} Rebuilding query indexes...");
+      const queryIndexArgs = ["--force", ...tenantId ? ["--tenant", tenantId] : []];
+      await runModuleCommand(allModules, "query_index", "reindex", queryIndexArgs);
+      console.log("\u2705 Query indexes rebuilt\n");
+      const [local, domain] = String(email).split("@");
+      const isSuperadminLocal = (local || "").toLowerCase() === "superadmin" && !!domain;
+      const adminEmailDerived = isSuperadminLocal ? `admin@${domain}` : null;
+      const employeeEmailDerived = isSuperadminLocal ? `employee@${domain}` : null;
+      console.log("\u{1F389} App initialization complete!\n");
+      console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+      console.log("\u2551  \u{1F680} You're now ready to start development!                   \u2551");
+      console.log("\u2551                                                              \u2551");
+      console.log("\u2551  Start the dev server:                                       \u2551");
+      console.log("\u2551    yarn dev                                                  \u2551");
+      console.log("\u2551                                                              \u2551");
+      console.log("\u2551  Users created:                                              \u2551");
+      console.log(`\u2551    \u{1F451} Superadmin: ${email.padEnd(42)} \u2551`);
+      console.log(`\u2551       Password: ${password.padEnd(44)} \u2551`);
+      if (adminEmailDerived) {
+        console.log(`\u2551    \u{1F9F0} Admin:      ${adminEmailDerived.padEnd(42)} \u2551`);
+        console.log(`\u2551       Password: ${password.padEnd(44)} \u2551`);
+      }
+      if (employeeEmailDerived) {
+        console.log(`\u2551    \u{1F477} Employee:   ${employeeEmailDerived.padEnd(42)} \u2551`);
+        console.log(`\u2551       Password: ${password.padEnd(44)} \u2551`);
+      }
+      console.log("\u2551                                                              \u2551");
+      console.log("\u2551  Happy coding!                                               \u2551");
+      console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+      return 0;
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("\u274C Initialization failed:", error.message);
+      } else {
+        console.error("\u274C Initialization failed:", error);
+      }
+      return 1;
+    }
+  }
+  let modName = first;
+  let cmdName = second;
+  let rest = remaining;
+  if (first === "reindex") {
+    modName = "query_index";
+    cmdName = "reindex";
+    rest = second !== void 0 ? [second, ...remaining] : remaining;
+  }
+  if (first === "generate" && !second) {
+    cmdName = "all";
+    rest = remaining;
+  }
+  const modules = getCliModules();
+  let appCli = [];
+  try {
+    const dynImport = Function("return import")();
+    const app = await dynImport.then((f) => f("@/cli")).catch(() => null);
+    if (app && Array.isArray(app?.default)) appCli = app.default;
+  } catch {
+  }
+  const all = modules.slice();
+  all.push({
+    id: "queue",
+    cli: [
+      {
+        command: "worker",
+        run: async (args) => {
+          const isAllQueues = args.includes("--all");
+          const queueName = isAllQueues ? null : args[0];
+          const allWorkers = [];
+          for (const mod2 of getCliModules()) {
+            const modWorkers = mod2.workers;
+            if (modWorkers) {
+              allWorkers.push(...modWorkers);
+            }
+          }
+          const discoveredQueues = [...new Set(allWorkers.map((w) => w.queue))];
+          if (!queueName && !isAllQueues) {
+            console.error("Usage: mercato queue worker <queueName> | --all");
+            console.error("Example: mercato queue worker events");
+            console.error("Example: mercato queue worker --all");
+            if (discoveredQueues.length > 0) {
+              console.error(`Discovered queues: ${discoveredQueues.join(", ")}`);
+            }
+            return;
+          }
+          const concurrencyArg = args.find((a) => a.startsWith("--concurrency="));
+          const concurrencyOverride = concurrencyArg ? Number(concurrencyArg.split("=")[1]) : void 0;
+          if (isAllQueues) {
+            if (discoveredQueues.length === 0) {
+              console.error("[worker] No queues discovered from modules");
+              return;
+            }
+            const container = await createRequestContainer();
+            console.log(`[worker] Starting workers for all queues: ${discoveredQueues.join(", ")}`);
+            const workerPromises = discoveredQueues.map(async (queue) => {
+              const queueWorkers = allWorkers.filter((w) => w.queue === queue);
+              const concurrency = concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1);
+              console.log(`[worker] Starting "${queue}" with ${queueWorkers.length} handler(s), concurrency: ${concurrency}`);
+              await runWorker({
+                queueName: queue,
+                connection: { url: process.env.REDIS_URL || process.env.QUEUE_REDIS_URL },
+                concurrency,
+                background: true,
+                handler: async (job, ctx) => {
+                  for (const worker of queueWorkers) {
+                    await worker.handler(job, { ...ctx, resolve: container.resolve.bind(container) });
+                  }
+                }
+              });
+            });
+            await Promise.all(workerPromises);
+            console.log("[worker] All workers started. Press Ctrl+C to stop");
+            await new Promise(() => {
+            });
+          } else {
+            const queueWorkers = allWorkers.filter((w) => w.queue === queueName);
+            if (queueWorkers.length > 0) {
+              const container = await createRequestContainer();
+              const concurrency = concurrencyOverride ?? Math.max(...queueWorkers.map((w) => w.concurrency), 1);
+              console.log(`[worker] Found ${queueWorkers.length} worker(s) for queue "${queueName}"`);
+              await runWorker({
+                queueName,
+                connection: { url: process.env.REDIS_URL || process.env.QUEUE_REDIS_URL },
+                concurrency,
+                handler: async (job, ctx) => {
+                  for (const worker of queueWorkers) {
+                    await worker.handler(job, { ...ctx, resolve: container.resolve.bind(container) });
+                  }
+                }
+              });
+            } else {
+              console.error(`No workers found for queue "${queueName}"`);
+              if (discoveredQueues.length > 0) {
+                console.error(`Available queues: ${discoveredQueues.join(", ")}`);
+              }
+            }
+          }
+        }
+      },
+      {
+        command: "clear",
+        run: async (args) => {
+          const queueName = args[0];
+          if (!queueName) {
+            console.error("Usage: mercato queue clear <queueName>");
+            return;
+          }
+          const strategyEnv = process.env.QUEUE_STRATEGY || "local";
+          const { createQueue } = await import("@open-mercato/queue");
+          const queue = strategyEnv === "async" ? createQueue(queueName, "async", {
+            connection: { url: process.env.REDIS_URL || process.env.QUEUE_REDIS_URL }
+          }) : createQueue(queueName, "local");
+          const res = await queue.clear();
+          await queue.close();
+          console.log(`Cleared queue "${queueName}", removed ${res.removed} jobs`);
+        }
+      },
+      {
+        command: "status",
+        run: async (args) => {
+          const queueName = args[0];
+          if (!queueName) {
+            console.error("Usage: mercato queue status <queueName>");
+            return;
+          }
+          const strategyEnv = process.env.QUEUE_STRATEGY || "local";
+          const { createQueue } = await import("@open-mercato/queue");
+          const queue = strategyEnv === "async" ? createQueue(queueName, "async", {
+            connection: { url: process.env.REDIS_URL || process.env.QUEUE_REDIS_URL }
+          }) : createQueue(queueName, "local");
+          const counts = await queue.getJobCounts();
+          console.log(`Queue "${queueName}" status:`);
+          console.log(`  Waiting:   ${counts.waiting}`);
+          console.log(`  Active:    ${counts.active}`);
+          console.log(`  Completed: ${counts.completed}`);
+          console.log(`  Failed:    ${counts.failed}`);
+          await queue.close();
+        }
+      }
+    ]
+  });
+  all.push({
+    id: "events",
+    cli: [
+      {
+        command: "emit",
+        run: async (args) => {
+          const eventName = args[0];
+          if (!eventName) {
+            console.error("Usage: mercato events emit <event> [jsonPayload] [--persistent|-p]");
+            return;
+          }
+          const persistent = args.includes("--persistent") || args.includes("-p");
+          const payloadArg = args[1] && !args[1].startsWith("--") ? args[1] : void 0;
+          let payload = {};
+          if (payloadArg) {
+            try {
+              payload = JSON.parse(payloadArg);
+            } catch {
+              payload = payloadArg;
+            }
+          }
+          const { createRequestContainer: createRequestContainer2 } = await import("@open-mercato/shared/lib/di/container");
+          const container = await createRequestContainer2();
+          const bus = container.resolve("eventBus");
+          await bus.emit(eventName, payload, { persistent });
+          console.log(`Emitted "${eventName}"${persistent ? " (persistent)" : ""}`);
+        }
+      },
+      {
+        command: "clear",
+        run: async () => {
+          const { createRequestContainer: createRequestContainer2 } = await import("@open-mercato/shared/lib/di/container");
+          const container = await createRequestContainer2();
+          const bus = container.resolve("eventBus");
+          const res = await bus.clearQueue();
+          console.log(`Cleared events queue, removed ${res.removed} events`);
+        }
+      }
+    ]
+  });
+  all.push({
+    id: "scaffold",
+    cli: [
+      {
+        command: "module",
+        run: async (args) => {
+          const name = (args[0] || "").trim();
+          if (!name) {
+            console.error("Usage: mercato scaffold module <name>");
+            return;
+          }
+          const fs2 = await import("node:fs");
+          const path2 = await import("node:path");
+          const { execSync } = await import("node:child_process");
+          const base = path2.resolve("src/modules", name);
+          const folders = ["api", "backend", "frontend", "data", "subscribers"];
+          for (const f of folders) fs2.mkdirSync(path2.join(base, f), { recursive: true });
+          const moduleTitle = `${name[0].toUpperCase()}${name.slice(1)}`;
+          const indexTs = `export const metadata = { title: '${moduleTitle}', group: 'Modules' }
+`;
+          fs2.writeFileSync(path2.join(base, "index.ts"), indexTs, { flag: "wx" });
+          const ceTs = `export const entities = [
+  {
+    id: '${name}:sample',
+    label: '${moduleTitle} Sample',
+    description: 'Describe your custom entity',
+    showInSidebar: true,
+    fields: [
+      // { key: 'priority', kind: 'integer', label: 'Priority' },
+    ],
+  },
+]
+
+export default entities
+`;
+          fs2.writeFileSync(path2.join(base, "ce.ts"), ceTs, { flag: "wx" });
+          const entitiesTs = `import { Entity, PrimaryKey, Property } from '@mikro-orm/core'
+
+// Add your entities here. Example:
+// @Entity({ tableName: '${name}_items' })
+// export class ${moduleTitle}Item {
+//   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' }) id!: string
+//   @Property({ type: 'text' }) title!: string
+//   @Property({ name: 'organization_id', type: 'uuid', nullable: true }) organizationId?: string | null
+//   @Property({ name: 'tenant_id', type: 'uuid', nullable: true }) tenantId?: string | null
+//   @Property({ name: 'created_at', type: Date, onCreate: () => new Date() }) createdAt: Date = new Date()
+//   @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() }) updatedAt: Date = new Date()
+//   @Property({ name: 'deleted_at', type: Date, nullable: true }) deletedAt?: Date | null
+// }
+`;
+          fs2.writeFileSync(path2.join(base, "data", "entities.ts"), entitiesTs, { flag: "wx" });
+          console.log(`Created module at ${path2.relative(process.cwd(), base)}`);
+          execSync("yarn modules:prepare", { stdio: "inherit" });
+        }
+      },
+      {
+        command: "entity",
+        run: async () => {
+          const fs2 = await import("node:fs");
+          const path2 = await import("node:path");
+          const readline = await import("node:readline/promises");
+          const { stdin: input, stdout: output } = await import("node:process");
+          const { execSync } = await import("node:child_process");
+          const rl = readline.createInterface({ input, output });
+          try {
+            const moduleId = (await rl.question("Module id (folder under src/modules): ")).trim();
+            const className = (await rl.question("Entity class name (e.g., Todo): ")).trim();
+            const tableName = (await rl.question(`DB table name (default: ${className.toLowerCase()}s): `)).trim() || `${className.toLowerCase()}s`;
+            const extra = (await rl.question("Additional fields (comma list name:type, e.g., title:text,is_done:boolean): ")).trim();
+            const extras = extra ? extra.split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+              const [n, t] = s.split(":").map((x) => x.trim());
+              return { n, t };
+            }) : [];
+            const base = path2.resolve("src/modules", moduleId, "data");
+            fs2.mkdirSync(base, { recursive: true });
+            const file = path2.join(base, "entities.ts");
+            let content = fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : `import { Entity, PrimaryKey, Property } from '@mikro-orm/core'
+
+`;
+            content += `
+@Entity({ tableName: '${tableName}' })
+export class ${className} {
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+
+  @Property({ name: 'tenant_id', type: 'uuid', nullable: true })
+  tenantId?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+`;
+            for (const f of extras) {
+              const n = f.n;
+              const t = f.t;
+              if (!n || !t) continue;
+              const map = {
+                text: { ts: "string", db: "text" },
+                multiline: { ts: "string", db: "text" },
+                integer: { ts: "number", db: "int" },
+                float: { ts: "number", db: "float" },
+                boolean: { ts: "boolean", db: "boolean" },
+                date: { ts: "Date", db: "Date" }
+              };
+              const info = map[t];
+              const fallback = { ts: "string", db: "text" };
+              const resolved = info || fallback;
+              const propName = n.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+              const columnName = n.replace(/[A-Z]/g, (m) => `_${m.toLowerCase()}`);
+              const dbType = resolved.db;
+              const tsType = resolved.ts;
+              const defaultValue = resolved.ts === "boolean" ? " = false" : resolved.ts === "Date" ? " = new Date()" : "";
+              content += `
+  @Property({ name: '${columnName}', type: ${dbType === "Date" ? "Date" : `'${dbType}'`}${resolved.ts === "boolean" ? ", default: false" : ""} })
+  ${propName}${tsType === "number" ? "?: number | null" : tsType === "boolean" ? ": boolean" : tsType === "Date" ? ": Date" : "!: string"}${defaultValue}
+`;
+            }
+            content += `}
+`;
+            fs2.writeFileSync(file, content);
+            console.log(`Updated ${path2.relative(process.cwd(), file)}`);
+            console.log("Generating and applying migrations...");
+            execSync("yarn modules:prepare", { stdio: "inherit" });
+            execSync("yarn db:generate", { stdio: "inherit" });
+            execSync("yarn db:migrate", { stdio: "inherit" });
+          } finally {
+            rl.close();
+          }
+        }
+      },
+      {
+        command: "crud",
+        run: async (args) => {
+          const fs2 = await import("node:fs");
+          const path2 = await import("node:path");
+          const { execSync } = await import("node:child_process");
+          const mod2 = (args[0] || "").trim();
+          const entity = (args[1] || "").trim();
+          const routeSeg = (args[2] || "").trim() || `${entity.toLowerCase()}s`;
+          if (!mod2 || !entity) {
+            console.error("Usage: mercato scaffold crud <moduleId> <EntityClass> [routeSegment]");
+            return;
+          }
+          const baseDir = path2.resolve("src/modules", mod2, "api", routeSeg);
+          fs2.mkdirSync(baseDir, { recursive: true });
+          const entitySnake = entity.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+          const tmpl = `import { z } from 'zod'
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import { ${entity} } from '@open-mercato/shared/modules/${mod2}/data/entities'
+import { E } from '#generated/entities.ids.generated'
+import ceEntities from '@open-mercato/shared/modules/${mod2}/ce'
+import { buildCustomFieldSelectorsForEntity, extractCustomFieldsFromItem, buildCustomFieldFiltersFromQuery } from '@open-mercato/shared/lib/crud/custom-fields'
+import type { CustomFieldSet } from '@open-mercato/shared/modules/entities'
+
+// Field constants - update these based on your entity's actual fields
+const F = {
+  id: 'id',
+  tenant_id: 'tenant_id',
+  organization_id: 'organization_id',
+  created_at: 'created_at',
+  updated_at: 'updated_at',
+  deleted_at: 'deleted_at',
+} as const
+
+const querySchema = z.object({
+  id: z.string().uuid().optional(),
+  page: z.coerce.number().min(1).default(1),
+  pageSize: z.coerce.number().min(1).max(100).default(50),
+  sortField: z.string().optional().default('id'),
+  sortDir: z.enum(['asc','desc']).optional().default('asc'),
+  withDeleted: z.coerce.boolean().optional().default(false),
+}).passthrough()
+
+const createSchema = z.object({}).passthrough()
+const updateSchema = z.object({ id: z.string().uuid() }).passthrough()
+
+type Query = z.infer<typeof querySchema>
+
+const fieldSets: CustomFieldSet[] = []
+const ceEntity = Array.isArray(ceEntities) ? ceEntities.find((entity) => entity?.id === '${mod2}:${entitySnake}') : undefined
+if (ceEntity?.fields?.length) {
+  fieldSets.push({ entity: ceEntity.id, fields: ceEntity.fields, source: '${mod2}' })
+}
+
+const cfSel = buildCustomFieldSelectorsForEntity(E.${mod2}.${entitySnake}, fieldSets)
+const sortFieldMap: Record<string, unknown> = { id: F.id, created_at: F.created_at, ...Object.fromEntries(cfSel.keys.map(k => [\`cf_\${k}\`, \`cf:\${k}\`])) }
+
+export const { metadata, GET, POST, PUT, DELETE } = makeCrudRoute({
+  metadata: { GET: { requireAuth: true }, POST: { requireAuth: true }, PUT: { requireAuth: true }, DELETE: { requireAuth: true } },
+  orm: { entity: ${entity}, idField: 'id', orgField: 'organizationId', tenantField: 'tenantId', softDeleteField: 'deletedAt' },
+  events: { module: '${mod2}', entity: '${entitySnake}', persistent: true },
+  indexer: { entityType: E.${mod2}.${entitySnake} },
+  list: {
+    schema: querySchema,
+    entityId: E.${mod2}.${entitySnake},
+    fields: [F.id, F.created_at, ...cfSel.selectors],
+    sortFieldMap,
+    buildFilters: async (q: Query, ctx) => ({
+      ...(await buildCustomFieldFiltersFromQuery({
+        entityId: E.${mod2}.${entitySnake},
+        query: q as any,
+        em: ctx.container.resolve('em'),
+        tenantId: ctx.auth!.tenantId,
+      })),
+    }),
+    transformItem: (item: any) => ({ id: item.id, created_at: item.created_at, ...extractCustomFieldsFromItem(item, cfSel.keys) }),
+  },
+  create: { schema: createSchema, mapToEntity: (input: any) => ({}), customFields: { enabled: true, entityId: E.${mod2}.${entitySnake}, pickPrefixed: true } },
+  update: { schema: updateSchema, applyToEntity: (entity: ${entity}, input: any) => {}, customFields: { enabled: true, entityId: E.${mod2}.${entitySnake}, pickPrefixed: true } },
+  del: { idFrom: 'query', softDelete: true },
+})
+`;
+          const file = path2.join(baseDir, "route.ts");
+          fs2.writeFileSync(file, tmpl, { flag: "wx" });
+          console.log(`Created CRUD route: ${path2.relative(process.cwd(), file)}`);
+          execSync("yarn modules:prepare", { stdio: "inherit" });
+        }
+      }
+    ]
+  });
+  all.push({
+    id: "generate",
+    cli: [
+      {
+        command: "all",
+        run: async (args) => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { generateEntityIds, generateModuleRegistry, generateModuleRegistryCli, generateModuleEntities, generateModuleDi } = await import("./lib/generators/index.js");
+          const resolver = createResolver();
+          const quiet = args.includes("--quiet") || args.includes("-q");
+          console.log("Running all generators...");
+          await generateEntityIds({ resolver, quiet });
+          await generateModuleRegistry({ resolver, quiet });
+          await generateModuleRegistryCli({ resolver, quiet });
+          await generateModuleEntities({ resolver, quiet });
+          await generateModuleDi({ resolver, quiet });
+          console.log("All generators completed.");
+        }
+      },
+      {
+        command: "entity-ids",
+        run: async (args) => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { generateEntityIds } = await import("./lib/generators/index.js");
+          const resolver = createResolver();
+          await generateEntityIds({ resolver, quiet: args.includes("--quiet") });
+        }
+      },
+      {
+        command: "registry",
+        run: async (args) => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { generateModuleRegistry } = await import("./lib/generators/index.js");
+          const resolver = createResolver();
+          await generateModuleRegistry({ resolver, quiet: args.includes("--quiet") });
+        }
+      },
+      {
+        command: "entities",
+        run: async (args) => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { generateModuleEntities } = await import("./lib/generators/index.js");
+          const resolver = createResolver();
+          await generateModuleEntities({ resolver, quiet: args.includes("--quiet") });
+        }
+      },
+      {
+        command: "di",
+        run: async (args) => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { generateModuleDi } = await import("./lib/generators/index.js");
+          const resolver = createResolver();
+          await generateModuleDi({ resolver, quiet: args.includes("--quiet") });
+        }
+      }
+    ]
+  });
+  all.push({
+    id: "db",
+    cli: [
+      {
+        command: "generate",
+        run: async () => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { dbGenerate } = await import("./lib/db/index.js");
+          const resolver = createResolver();
+          await dbGenerate(resolver);
+        }
+      },
+      {
+        command: "migrate",
+        run: async () => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { dbMigrate } = await import("./lib/db/index.js");
+          const resolver = createResolver();
+          await dbMigrate(resolver);
+        }
+      },
+      {
+        command: "greenfield",
+        run: async (args) => {
+          const { createResolver } = await import("./lib/resolver.js");
+          const { dbGreenfield } = await import("./lib/db/index.js");
+          const resolver = createResolver();
+          const yes = args.includes("--yes") || args.includes("-y");
+          await dbGreenfield(resolver, { yes });
+        }
+      }
+    ]
+  });
+  all.push({
+    id: "server",
+    cli: [
+      {
+        command: "dev",
+        run: async () => {
+          const { spawn } = await import("child_process");
+          const path2 = await import("path");
+          const { createResolver } = await import("./lib/resolver.js");
+          const resolver = createResolver();
+          const appDir = resolver.getAppDir();
+          const nodeModulesBase = resolver.isMonorepo() ? resolver.getRootDir() : appDir;
+          const processes = [];
+          const autoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS !== "false";
+          function cleanup() {
+            console.log("[server] Shutting down...");
+            for (const proc of processes) {
+              if (!proc.killed) {
+                proc.kill("SIGTERM");
+              }
+            }
+          }
+          process.on("SIGTERM", cleanup);
+          process.on("SIGINT", cleanup);
+          console.log("[server] Starting Open Mercato in dev mode...");
+          const nextBin = path2.join(nodeModulesBase, "node_modules/next/dist/bin/next");
+          const mercatoBin = path2.join(nodeModulesBase, "node_modules/@open-mercato/cli/bin/mercato");
+          const nextProcess = spawn("node", [nextBin, "dev", "--turbopack"], {
+            stdio: "inherit",
+            env: process.env,
+            cwd: appDir
+          });
+          processes.push(nextProcess);
+          if (autoSpawnWorkers) {
+            console.log("[server] Starting workers for all queues...");
+            const workerProcess = spawn("node", [mercatoBin, "queue", "worker", "--all"], {
+              stdio: "inherit",
+              env: process.env,
+              cwd: appDir
+            });
+            processes.push(workerProcess);
+          }
+          await Promise.race(
+            processes.map(
+              (proc) => new Promise((resolve) => {
+                proc.on("exit", () => resolve());
+              })
+            )
+          );
+          cleanup();
+        }
+      },
+      {
+        command: "start",
+        run: async () => {
+          const { spawn } = await import("child_process");
+          const path2 = await import("path");
+          const { createResolver } = await import("./lib/resolver.js");
+          const resolver = createResolver();
+          const appDir = resolver.getAppDir();
+          const nodeModulesBase = resolver.isMonorepo() ? resolver.getRootDir() : appDir;
+          const processes = [];
+          const autoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS !== "false";
+          function cleanup() {
+            console.log("[server] Shutting down...");
+            for (const proc of processes) {
+              if (!proc.killed) {
+                proc.kill("SIGTERM");
+              }
+            }
+          }
+          process.on("SIGTERM", cleanup);
+          process.on("SIGINT", cleanup);
+          console.log("[server] Starting Open Mercato in production mode...");
+          const nextBin = path2.join(nodeModulesBase, "node_modules/next/dist/bin/next");
+          const mercatoBin = path2.join(nodeModulesBase, "node_modules/@open-mercato/cli/bin/mercato");
+          const nextProcess = spawn("node", [nextBin, "start"], {
+            stdio: "inherit",
+            env: process.env,
+            cwd: appDir
+          });
+          processes.push(nextProcess);
+          if (autoSpawnWorkers) {
+            console.log("[server] Starting workers for all queues...");
+            const workerProcess = spawn("node", [mercatoBin, "queue", "worker", "--all"], {
+              stdio: "inherit",
+              env: process.env,
+              cwd: appDir
+            });
+            processes.push(workerProcess);
+          }
+          await Promise.race(
+            processes.map(
+              (proc) => new Promise((resolve) => {
+                proc.on("exit", () => resolve());
+              })
+            )
+          );
+          cleanup();
+        }
+      }
+    ]
+  });
+  if (appCli.length) all.push({ id: "app", cli: appCli });
+  const quietBanner = process.env.OM_CLI_QUIET === "1";
+  const banner = "\u{1F9E9} Open Mercato CLI";
+  if (!quietBanner) {
+    const header = [
+      "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+      `\u2551  ${banner.padEnd(21)}\u2551`,
+      "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+    ].join("\n");
+    console.log(header);
+  }
+  const pad = (s) => `  ${s}`;
+  if (!modName || modName === "help" || modName === "--help" || modName === "-h") {
+    console.log(pad("Usage: \u2728 mercato <module> <command> [args]"));
+    const list = all.filter((m) => m.cli && m.cli.length).map((m) => `\u2022 ${m.id}: ${m.cli.map((c) => `"${c.command}"`).join(", ")}`);
+    if (list.length) {
+      console.log("\n" + pad("Available:"));
+      console.log(list.map(pad).join("\n"));
+    } else {
+      console.log(pad("\u{1F300} No CLI commands available"));
+    }
+    return 0;
+  }
+  const mod = all.find((m) => m.id === modName);
+  if (!mod) {
+    console.error(`\u274C Module not found: "${modName}"`);
+    return 1;
+  }
+  if (!mod.cli || mod.cli.length === 0) {
+    console.error(`\u{1F6AB} Module "${modName}" has no CLI commands`);
+    return 1;
+  }
+  if (!cmdName) {
+    console.log(pad(`Commands for "${modName}": ${mod.cli.map((c) => c.command).join(", ")}`));
+    return 1;
+  }
+  const cmd = mod.cli.find((c) => c.command === cmdName);
+  if (!cmd) {
+    console.error(`\u{1F914} Unknown command "${cmdName}". Available: ${mod.cli.map((c) => c.command).join(", ")}`);
+    return 1;
+  }
+  console.log("");
+  const started = Date.now();
+  console.log(`\u{1F680} Running ${modName}:${cmdName} ${rest.join(" ")}`);
+  try {
+    await cmd.run(rest);
+    const ms = Date.now() - started;
+    console.log(`\u23F1\uFE0F Done in ${ms}ms`);
+    return 0;
+  } catch (e) {
+    console.error(`\u{1F4A5} Failed: ${e?.message || e}`);
+    return 1;
+  }
+}
+export {
+  getCliModules,
+  hasCliModules,
+  registerCliModules,
+  run
+};
+//# sourceMappingURL=mercato.js.map