qarpeo 0.0.0-alpha.10

package/dist/chunks/wrangler.mjs

@@ -0,0 +1,783 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, statSync, readdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { drizzle } from 'drizzle-orm/node-sqlite';
+import { resolve, dirname, join, extname, basename, relative } from 'pathe';
+import { stdin, stdout } from 'node:process';
+import readline from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { defu } from 'defu';
+
+function scanSchemaExports(schemaFiles) {
+  const types = [];
+  const zod = [];
+  for (const file of schemaFiles) {
+    let src;
+    try {
+      src = readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const m of src.matchAll(/^export\s+type\s+([A-Z][A-Za-z0-9_]*)\b/gm)) {
+      types.push({ name: m[1], file });
+    }
+    for (const m of src.matchAll(/^export\s+const\s+([a-z][A-Za-z0-9_]*Schema)\b/gm)) {
+      zod.push({ name: m[1], file });
+    }
+  }
+  return { types, zod };
+}
+function checkDrizzleVersion(rootDir) {
+  try {
+    let req;
+    let entry;
+    try {
+      req = createRequire(resolve(rootDir, "package.json"));
+      entry = req.resolve("drizzle-orm");
+    } catch {
+      req = createRequire(import.meta.url);
+      entry = req.resolve("drizzle-orm");
+    }
+    let dir = dirname(entry);
+    let pkgJsonPath = null;
+    while (dir !== dirname(dir)) {
+      const candidate = resolve(dir, "package.json");
+      if (existsSync(candidate)) {
+        try {
+          const pkg2 = JSON.parse(readFileSync(candidate, "utf-8"));
+          if (pkg2.name === "drizzle-orm") {
+            pkgJsonPath = candidate;
+            break;
+          }
+        } catch {
+        }
+      }
+      dir = dirname(dir);
+    }
+    if (!pkgJsonPath) {
+      return {
+        installed: false,
+        isRC: false,
+        error: `[qarpeo] Could not locate drizzle-orm package.json.`
+      };
+    }
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    const version = pkg.version || "";
+    const isLegacy = version.startsWith("0.");
+    if (isLegacy) {
+      return {
+        installed: true,
+        version,
+        isRC: false,
+        error: `[qarpeo] Outdated "drizzle-orm" detected in your project (v${version}).
+qarpeo requires Drizzle ORM v1.0.0 RC (drizzle-orm@rc) or newer.
+Please remove or upgrade your project's drizzle-orm dependency:
+  pnpm add drizzle-orm@rc`
+      };
+    }
+    return {
+      installed: true,
+      version,
+      isRC: true
+    };
+  } catch {
+    return {
+      installed: false,
+      isRC: false,
+      error: `[qarpeo] Drizzle ORM is enabled (db: { orm: 'drizzle' }), but "drizzle-orm" could not be resolved.
+Please ensure qarpeo dependencies are installed.`
+    };
+  }
+}
+function findSchemaFiles(layers) {
+  const schemaFiles = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const baseDirs = /* @__PURE__ */ new Set();
+    if (layer.config?.srcDir) baseDirs.add(layer.config.srcDir);
+    if (layer.config?.rootDir) baseDirs.add(layer.config.rootDir);
+    if (layer.cwd) baseDirs.add(layer.cwd);
+    for (const baseDir of baseDirs) {
+      const dbSchemaFile = resolve(baseDir, "server/db/schema.ts");
+      if (existsSync(dbSchemaFile)) {
+        schemaFiles.add(dbSchemaFile);
+      }
+      const dbSchemaDir = resolve(baseDir, "server/db/schema");
+      if (existsSync(dbSchemaDir) && statSync(dbSchemaDir).isDirectory()) {
+        const indexFile = resolve(dbSchemaDir, "index.ts");
+        if (existsSync(indexFile)) {
+          schemaFiles.add(indexFile);
+        } else {
+          for (const file of readdirSync(dbSchemaDir)) {
+            if (file.endsWith(".ts") && !file.endsWith(".d.ts")) {
+              schemaFiles.add(resolve(dbSchemaDir, file));
+            }
+          }
+        }
+      }
+      const databaseSchemaFile = resolve(baseDir, "server/database/schema.ts");
+      if (existsSync(databaseSchemaFile)) {
+        schemaFiles.add(databaseSchemaFile);
+      }
+      const databaseSchemaDir = resolve(baseDir, "server/database/schema");
+      if (existsSync(databaseSchemaDir) && statSync(databaseSchemaDir).isDirectory()) {
+        const indexFile = resolve(databaseSchemaDir, "index.ts");
+        if (existsSync(indexFile)) {
+          schemaFiles.add(indexFile);
+        } else {
+          for (const file of readdirSync(databaseSchemaDir)) {
+            if (file.endsWith(".ts") && !file.endsWith(".d.ts")) {
+              schemaFiles.add(resolve(databaseSchemaDir, file));
+            }
+          }
+        }
+      }
+      const serverSchema = resolve(baseDir, "server/schema.ts");
+      if (existsSync(serverSchema)) {
+        schemaFiles.add(serverSchema);
+      }
+    }
+  }
+  return Array.from(schemaFiles);
+}
+
+function isPackageInstalled(packageName, cwd = process.cwd()) {
+  const localDir = resolve(cwd, "node_modules", packageName);
+  const rootDir = resolve(cwd, "../node_modules", packageName);
+  if (existsSync(localDir) || existsSync(rootDir)) {
+    return true;
+  }
+  try {
+    const req = createRequire(resolve(cwd, "package.json"));
+    req.resolve(packageName);
+    return true;
+  } catch {
+    try {
+      const selfReq = createRequire(import.meta.url);
+      selfReq.resolve(packageName);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function resolveBinaryPath(binName, cwd = process.cwd()) {
+  const isWindows = process.platform === "win32";
+  const actualBin = isWindows ? `${binName}.cmd` : binName;
+  const localBin = resolve(cwd, "node_modules/.bin", actualBin);
+  if (existsSync(localBin)) return localBin;
+  const rootBin = resolve(cwd, "../node_modules/.bin", actualBin);
+  if (existsSync(rootBin)) return rootBin;
+  try {
+    let currentDir = dirname(fileURLToPath(import.meta.url));
+    while (currentDir !== dirname(currentDir)) {
+      const binCandidate = resolve(currentDir, "node_modules/.bin", actualBin);
+      if (existsSync(binCandidate)) {
+        return binCandidate;
+      }
+      currentDir = dirname(currentDir);
+    }
+  } catch {
+  }
+  return null;
+}
+async function confirmInstall(packageName, purpose) {
+  if (!stdin.isTTY) {
+    return false;
+  }
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await rl.question(
+      `
+\u{1F4E6} [qarpeo] "${packageName}" is required for ${purpose}.
+   Would you like to install it now? (Y/n): `
+    );
+    return answer.trim().toLowerCase() !== "n";
+  } finally {
+    rl.close();
+  }
+}
+async function ensurePackage(packageName, options) {
+  const cwd = options.cwd || process.cwd();
+  if (isPackageInstalled(packageName, cwd)) {
+    return true;
+  }
+  const confirmed = await confirmInstall(packageName, options.purpose);
+  if (!confirmed) {
+    console.error(
+      `
+\u274C [qarpeo] Missing dependency: "${packageName}". Please install it manually:
+   pnpm add ${options.dev ? "-D " : ""}${packageName}
+`
+    );
+    return false;
+  }
+  console.log(`
+\u26A1 [qarpeo] Installing ${packageName}...`);
+  try {
+    const { addDependency } = await import('nypm');
+    await addDependency(packageName, {
+      cwd,
+      dev: options.dev ?? true,
+      silent: false
+    });
+    console.log(`\u2705 [qarpeo] Successfully installed ${packageName}!
+`);
+    return true;
+  } catch (err) {
+    console.error(`\u274C [qarpeo] Failed to install ${packageName}:`, err?.message || err);
+    return false;
+  }
+}
+
+function findLocalD1Database(cwd) {
+  const possibleDirs = [
+    resolve(cwd, ".wrangler/state/v3/d1/miniflare-D1DatabaseObject"),
+    resolve(cwd, ".data/db")
+  ];
+  for (const dir of possibleDirs) {
+    if (existsSync(dir)) {
+      const files = readdirSync(dir).filter((f) => f.endsWith(".sqlite") || f.endsWith(".db")).filter((f) => !f.endsWith("-journal") && !f.endsWith("-wal") && !f.endsWith("-shm"));
+      if (files.length === 1) {
+        return resolve(dir, files[0]);
+      }
+      if (files.length > 1) {
+        const sorted = files.map((f) => ({ path: resolve(dir, f), mtime: statSync(resolve(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+        return sorted[0].path;
+      }
+    }
+  }
+  return null;
+}
+async function getJiti(cwd) {
+  const req = createRequire(import.meta.url);
+  try {
+    const jitiEntry = req.resolve("jiti");
+    const { createJiti } = await import(jitiEntry);
+    return createJiti(cwd, { interopDefault: true });
+  } catch {
+    const jitiMod = await import('jiti');
+    return (jitiMod.createJiti || jitiMod.default || jitiMod)(cwd, { interopDefault: true });
+  }
+}
+async function getLocalDatabaseContext(cwd, nuxtConfig) {
+  const sqlitePath = findLocalD1Database(cwd);
+  if (!sqlitePath) {
+    throw new Error(
+      `No local D1 database found in .wrangler/state/v3/d1.
+Please apply migrations first: qp db:migrate`
+    );
+  }
+  const layers = nuxtConfig._layers || [{ cwd, config: nuxtConfig }];
+  const schemaFiles = findSchemaFiles(layers);
+  if (schemaFiles.length === 0) {
+    throw new Error(
+      `No database schema files found. Create a schema file at server/db/schema.ts first.`
+    );
+  }
+  const jiti = await getJiti(cwd);
+  const schema = {};
+  for (const file of schemaFiles) {
+    try {
+      const mod = await jiti.import(file);
+      Object.assign(schema, mod);
+    } catch (err) {
+      console.warn(`[qarpeo] Warning: Failed to import schema file ${file}: ${err?.message || err}`);
+    }
+  }
+  const db = drizzle(sqlitePath);
+  let customSeedPath = null;
+  for (const candidate of [
+    resolve(cwd, "server/db/seed.ts"),
+    resolve(cwd, "server/db/seed.js"),
+    resolve(cwd, "server/database/seed.ts"),
+    resolve(cwd, "server/database/seed.js")
+  ]) {
+    if (existsSync(candidate)) {
+      customSeedPath = candidate;
+      break;
+    }
+  }
+  return {
+    sqlitePath,
+    schema,
+    db,
+    customSeedPath
+  };
+}
+function applyD1Migrations(cwd, options = {}) {
+  const serverDir = options.serverDir || resolve(cwd, "server");
+  const migrationsDir = resolve(serverDir, "db/migrations");
+  if (!existsSync(migrationsDir)) {
+    return true;
+  }
+  try {
+    const entries = readdirSync(migrationsDir, { withFileTypes: true });
+    const hasSql = entries.some(
+      (e) => e.isFile() && e.name.endsWith(".sql") || e.isDirectory() && existsSync(resolve(migrationsDir, e.name, "migration.sql"))
+    );
+    if (!hasSql) {
+      return true;
+    }
+  } catch {
+    return true;
+  }
+  const isWindows = process.platform === "win32";
+  let execPath = resolveBinaryPath("wrangler", cwd);
+  if (!execPath) {
+    execPath = isWindows ? "wrangler.cmd" : "wrangler";
+  }
+  const dbName = options.dbName || "DB";
+  const wranglerConfigPath = options.wranglerConfigPath || resolve(cwd, ".nuxt/wrangler.json");
+  const wranglerArgs = ["d1", "migrations", "apply", dbName];
+  if (existsSync(wranglerConfigPath)) {
+    wranglerArgs.push("-c", wranglerConfigPath);
+  }
+  if (options.remote) {
+    wranglerArgs.push("--remote");
+  } else {
+    wranglerArgs.push("--local", "--persist-to", resolve(cwd, ".wrangler/state"));
+  }
+  const targetLabel = options.remote ? "remote Cloudflare D1" : "local Cloudflare D1";
+  const actionLabel = options.label || "Auto-checking";
+  console.log(`\u26A1 [qarpeo] ${actionLabel}: applying ${targetLabel} migrations...`);
+  try {
+    const result = spawnSync(execPath, wranglerArgs, {
+      cwd,
+      stdio: "inherit",
+      shell: isWindows
+    });
+    return result.status === 0;
+  } catch (err) {
+    console.warn(`\u26A0\uFE0F [qarpeo] Migration failed: ${err?.message || err}`);
+    return false;
+  }
+}
+
+const localDb = {
+  __proto__: null,
+  applyD1Migrations: applyD1Migrations,
+  findLocalD1Database: findLocalD1Database,
+  getJiti: getJiti,
+  getLocalDatabaseContext: getLocalDatabaseContext
+};
+
+function resolveBindingName(service, override, defaultName) {
+  if (override && typeof override === "string") {
+    return override;
+  }
+  const upper = service.toUpperCase();
+  return process.env[`QARPEO_DEFAULT_${upper}_BINDING`] || process.env[`QARPEO_${upper}_BINDING`] || process.env[`${upper}_BINDING`] || defaultName || upper;
+}
+
+function findJobFiles(layers, dirName = "server/jobs") {
+  const jobsMap = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    const baseDirs = /* @__PURE__ */ new Set();
+    if (layer.config?.srcDir) baseDirs.add(layer.config.srcDir);
+    if (layer.config?.rootDir) baseDirs.add(layer.config.rootDir);
+    if (layer.cwd) baseDirs.add(layer.cwd);
+    for (const baseDir of baseDirs) {
+      const jobsDir = resolve(baseDir, dirName);
+      if (!existsSync(jobsDir)) continue;
+      try {
+        const entries = readdirSync(jobsDir);
+        for (const entry of entries) {
+          const fullPath = join(jobsDir, entry);
+          const stat = statSync(fullPath);
+          if (stat.isFile() && (entry.endsWith(".ts") || entry.endsWith(".js") || entry.endsWith(".mjs"))) {
+            if (entry.endsWith(".d.ts")) continue;
+            const ext = extname(entry);
+            const name = basename(entry, ext);
+            const importPath = fullPath.replace(/\\/g, "/").replace(/\.(ts|js|mjs)$/, "");
+            jobsMap.set(name, { name, file: fullPath, importPath });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return Array.from(jobsMap.values());
+}
+
+function findQueueFiles(layers) {
+  const queueFiles = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const baseDirs = /* @__PURE__ */ new Set();
+    if (layer.config?.srcDir) baseDirs.add(layer.config.srcDir);
+    if (layer.config?.rootDir) baseDirs.add(layer.config.rootDir);
+    if (layer.cwd) baseDirs.add(layer.cwd);
+    for (const baseDir of baseDirs) {
+      const queueFile = resolve(baseDir, "server/queue.ts");
+      if (existsSync(queueFile)) {
+        queueFiles.add(queueFile);
+      }
+      const queueIndexFile = resolve(baseDir, "server/queue/index.ts");
+      if (existsSync(queueIndexFile)) {
+        queueFiles.add(queueIndexFile);
+      }
+    }
+  }
+  return Array.from(queueFiles);
+}
+
+function resolveProjectName(nuxt, options) {
+  if (options?.site?.name) return options.site.name;
+  if (options?.name) return options.name;
+  const qarpeoConfig = nuxt.options.qarpeo || {};
+  if (qarpeoConfig.site?.name) return qarpeoConfig.site.name;
+  if (qarpeoConfig.name) return qarpeoConfig.name;
+  const siteConfig = nuxt.options.site || {};
+  if (siteConfig.name) return siteConfig.name;
+  if (process.env.CLOUDFLARE_PROJECT_NAME) return process.env.CLOUDFLARE_PROJECT_NAME;
+  if (process.env.WRANGLER_NAME) return process.env.WRANGLER_NAME;
+  try {
+    const pkgPath = resolve(nuxt.options.rootDir, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      if (pkg.name) return pkg.name;
+    }
+  } catch {
+  }
+  return "qarpeo-app";
+}
+async function createWranglerConfig(nuxt, options) {
+  let rootConfig = {};
+  for (const file of ["wrangler.jsonc", "wrangler.json"]) {
+    const rootPath = join(nuxt.options.rootDir, file);
+    if (existsSync(rootPath)) {
+      try {
+        const content = await readFile(rootPath, "utf8");
+        const stripped = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/,\s*([}\]])/g, "$1");
+        rootConfig = JSON.parse(stripped);
+        break;
+      } catch {
+      }
+    }
+  }
+  const compatDate = typeof nuxt.options.compatibilityDate === "string" ? nuxt.options.compatibilityDate : nuxt.options.compatibilityDate?.default || "2025-02-01";
+  const projectName = resolveProjectName(nuxt, options);
+  const baseConfig = {
+    $schema: "node_modules/wrangler/config-schema.json",
+    name: projectName,
+    compatibility_date: compatDate,
+    compatibility_flags: ["nodejs_compat"],
+    observability: { enabled: true }
+  };
+  const isRemote = Boolean(options.remote || process.env.QARPEO_CF_REMOTE);
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || process.env.CF_ACCOUNT_ID;
+  if (accountId) {
+    baseConfig.account_id = accountId;
+  }
+  if (options.kv || options.cache || options.auth || options.realtime || options.payments || options.ratelimit || options.agents || options.multitenant) {
+    const kvBinding = resolveBindingName("kv");
+    const kvId = process.env.QARPEO_KV_ID || process.env.KV_ID || `${kvBinding}_LOCAL_DEV`;
+    baseConfig.kv_namespaces = [
+      {
+        binding: kvBinding,
+        id: kvId,
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+  }
+  if (options.blob || options.r2 || options.cms || options.storage) {
+    const blobBinding = resolveBindingName("blob");
+    const bucketName = process.env.QARPEO_BLOB_BUCKET || process.env.BLOB_NAME || `${blobBinding.toLowerCase().replace(/[^a-z0-9-]/g, "-")}-local-dev`;
+    baseConfig.r2_buckets = [
+      {
+        binding: blobBinding,
+        bucket_name: bucketName,
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+  }
+  if (options.db || options.d1 || options.cms || options.auth || options.payments) {
+    const dbBinding = resolveBindingName(
+      "db",
+      typeof options.db === "object" ? options.db.binding : void 0
+    );
+    const dbId = typeof options.db === "object" && options.db.databaseId || process.env.QARPEO_DB_ID || process.env.DATABASE_ID || process.env.DB_ID || `${dbBinding}_LOCAL_DEV`;
+    const serverDir = nuxt.options.serverDir || resolve(nuxt.options.rootDir, "server");
+    const migrationsDir = resolve(serverDir, "db/migrations");
+    const buildDir = nuxt.options.buildDir || resolve(nuxt.options.rootDir, ".nuxt");
+    const relMigrationsDir = relative(buildDir, migrationsDir).replace(/\\/g, "/");
+    baseConfig.d1_databases = [
+      {
+        binding: dbBinding,
+        database_name: dbBinding,
+        database_id: dbId,
+        migrations_dir: relMigrationsDir,
+        migrations_pattern: `${relMigrationsDir}/*/migration.sql`,
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+  }
+  if (options.cache) {
+    const cacheConfig = typeof options.cache === "object" ? options.cache : {};
+    const cacheBinding = cacheConfig.binding || resolveBindingName("cache");
+    const cacheId = process.env.QARPEO_CACHE_ID || process.env.CACHE_ID || `${cacheBinding}_LOCAL_DEV`;
+    baseConfig.kv_namespaces = baseConfig.kv_namespaces || [];
+    baseConfig.kv_namespaces.push({
+      binding: cacheBinding,
+      id: cacheId,
+      ...isRemote ? { remote: true } : {}
+    });
+  }
+  if (options.ai || options.agents) {
+    const hasToken = Boolean(
+      process.env.CLOUDFLARE_API_TOKEN || process.env.CLOUDFLARE_ACCOUNT_ID || isRemote
+    );
+    if (hasToken || !nuxt.options.dev) {
+      const aiBinding = resolveBindingName("ai");
+      baseConfig.ai = {
+        binding: aiBinding
+      };
+    }
+  }
+  if (options.vectorize || options.agents) {
+    const vectorizeBinding = resolveBindingName("vectorize");
+    const indexName = `${vectorizeBinding.toLowerCase().replace(/[^a-z0-9-]/g, "-")}-local-dev`;
+    baseConfig.vectorize = [
+      {
+        binding: vectorizeBinding,
+        index_name: indexName,
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+  }
+  if (options.queue || options.jobs || options.payments) {
+    const queueBinding = resolveBindingName("queue");
+    const queueName = process.env.QARPEO_QUEUE_NAME || `${queueBinding.toLowerCase().replace(/[^a-z0-9-]/g, "-")}-local-dev`;
+    baseConfig.queues = baseConfig.queues || {};
+    baseConfig.queues.producers = [
+      {
+        binding: queueBinding,
+        queue: queueName,
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+    const queueFiles = findQueueFiles(
+      nuxt.options._layers || [{ cwd: nuxt.options.rootDir, config: nuxt.options }]
+    );
+    const jobFiles = options.jobs ? findJobFiles(
+      nuxt.options._layers || [{ cwd: nuxt.options.rootDir, config: nuxt.options }],
+      typeof options.jobs === "object" && options.jobs.dir ? options.jobs.dir : "server/jobs"
+    ) : [];
+    if (queueFiles.length > 0 || jobFiles.length > 0) {
+      const jobsConfig = typeof options.jobs === "object" ? options.jobs : {};
+      baseConfig.queues.consumers = [
+        {
+          queue: queueName,
+          max_batch_size: jobsConfig.maxBatchSize ?? 10,
+          max_batch_timeout: jobsConfig.maxBatchTimeout ?? 5
+        }
+      ];
+    }
+  }
+  if (options.analytics) {
+    const analyticsOpts = typeof options.analytics === "object" ? options.analytics : void 0;
+    const analyticsBinding = resolveBindingName("analytics", analyticsOpts?.binding);
+    const datasetName = analyticsOpts?.dataset || process.env.QARPEO_ANALYTICS_DATASET || `${analyticsBinding.toLowerCase().replace(/[^a-z0-9-]/g, "-")}-local-dev`;
+    baseConfig.analytics_engine_datasets = [
+      {
+        binding: analyticsBinding,
+        dataset: datasetName
+      }
+    ];
+  }
+  if (options.ratelimit) {
+    const rateLimitBinding = resolveBindingName("ratelimit", void 0, "RATE_LIMITER");
+    const limit = typeof options.ratelimit === "object" ? options.ratelimit.limit ?? 100 : 100;
+    const period = typeof options.ratelimit === "object" ? options.ratelimit.period ?? 60 : 60;
+    const namespaceId = typeof options.ratelimit === "object" ? options.ratelimit.namespaceId ?? 1001 : 1001;
+    baseConfig.ratelimits = [
+      {
+        name: rateLimitBinding,
+        namespace_id: String(namespaceId),
+        simple: {
+          limit,
+          period
+        }
+      }
+    ];
+  }
+  if (options.hyperdrive) {
+    const hyperdriveBinding = resolveBindingName("hyperdrive");
+    const id = process.env.QARPEO_HYPERDRIVE_ID || `${hyperdriveBinding}_LOCAL_DEV`;
+    const localConnectionString = (typeof options.hyperdrive === "object" ? options.hyperdrive.localConnectionString : void 0) || process.env.LOCAL_CONNECTION_STRING || process.env.QARPEO_HYPERDRIVE_LOCAL_URL;
+    baseConfig.hyperdrive = [
+      {
+        binding: hyperdriveBinding,
+        id,
+        ...localConnectionString ? { localConnectionString } : nuxt.options.dev && !isRemote ? { localConnectionString: "postgresql://postgres:postgres@localhost:5432/postgres" } : {},
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+  }
+  if (options.browser) {
+    const browserBinding = resolveBindingName("browser");
+    baseConfig.browser = {
+      binding: browserBinding
+    };
+  }
+  if (options.email || options.mail) {
+    const emailBinding = resolveBindingName(
+      "email",
+      typeof options.email === "object" ? options.email.binding : void 0,
+      "EMAIL"
+    );
+    baseConfig.send_email = [
+      {
+        name: emailBinding,
+        ...isRemote ? { remote: true } : {}
+      }
+    ];
+  }
+  const isCronDisabled = options.cron === false;
+  if (!isCronDisabled) {
+    let crons = [];
+    if (options.cron && typeof options.cron === "object") {
+      crons = Object.keys(options.cron);
+    }
+    if (!crons.length) {
+      const nitroScheduled = nuxt.options.nitro?.scheduledTasks;
+      const nitroCrons = nitroScheduled ? Object.keys(nitroScheduled) : [];
+      crons = nuxt.options.nitro?.cloudflare?.wrangler?.triggers?.crons || nitroCrons;
+    }
+    const cmsScheduled = typeof options.cms === "object" && options.cms?.scheduledPublish;
+    if (cmsScheduled && !crons.includes("*/5 * * * *")) {
+      crons.push("*/5 * * * *");
+    }
+    if (crons.length > 0) {
+      baseConfig.triggers = { crons };
+    }
+  }
+  if (options.do || options.realtime || options.agents) {
+    baseConfig.durable_objects = baseConfig.durable_objects || { bindings: [] };
+    baseConfig.durable_objects.bindings = baseConfig.durable_objects.bindings || [];
+    baseConfig.migrations = baseConfig.migrations || [];
+    if (options.realtime || !options.agents && options.do) {
+      const doBinding = resolveBindingName(
+        "do",
+        typeof options.realtime === "object" ? options.realtime.binding : void 0,
+        "QARPEO_ROOM_DO"
+      );
+      baseConfig.durable_objects.bindings.push({
+        name: doBinding,
+        class_name: "QarpeoRoomDO"
+      });
+      baseConfig.migrations.push({
+        tag: "v1-realtime-room",
+        new_classes: ["QarpeoRoomDO"]
+      });
+    }
+    if (options.agents) {
+      const agentsConfig = typeof options.agents === "object" ? options.agents : {};
+      const agentBinding = agentsConfig.binding || "QARPEO_AGENT_DO";
+      baseConfig.durable_objects.bindings.push({
+        name: agentBinding,
+        class_name: "QarpeoAgentDO"
+      });
+      baseConfig.migrations.push({
+        tag: "v1-agent-do",
+        new_sqlite_classes: ["QarpeoAgentDO"]
+      });
+    }
+  }
+  const merged = defu(rootConfig, baseConfig);
+  if (Array.isArray(merged.kv_namespaces)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.kv_namespaces = merged.kv_namespaces.filter((item) => {
+      if (!item?.binding || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.r2_buckets)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.r2_buckets = merged.r2_buckets.filter((item) => {
+      if (!item?.binding || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.d1_databases)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.d1_databases = merged.d1_databases.filter((item) => {
+      if (!item?.binding || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.vectorize)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.vectorize = merged.vectorize.filter((item) => {
+      if (!item?.binding || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.analytics_engine_datasets)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.analytics_engine_datasets = merged.analytics_engine_datasets.filter((item) => {
+      if (!item?.binding || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.ratelimits)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.ratelimits = merged.ratelimits.filter((item) => {
+      if (!item?.name || seen.has(item.name)) return false;
+      seen.add(item.name);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.hyperdrive)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.hyperdrive = merged.hyperdrive.filter((item) => {
+      if (!item?.binding || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      return true;
+    });
+  }
+  if (Array.isArray(merged.send_email)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.send_email = merged.send_email.filter((item) => {
+      if (!item?.name || seen.has(item.name)) return false;
+      seen.add(item.name);
+      return true;
+    });
+  }
+  if (merged.durable_objects && Array.isArray(merged.durable_objects.bindings)) {
+    const seen = /* @__PURE__ */ new Set();
+    merged.durable_objects.bindings = merged.durable_objects.bindings.filter((item) => {
+      if (!item?.name || seen.has(item.name)) return false;
+      seen.add(item.name);
+      return true;
+    });
+  }
+  return merged;
+}
+async function generateDevWranglerConfig(nuxt, options) {
+  const buildDir = nuxt.options.buildDir;
+  const configPath = join(buildDir, "wrangler.json");
+  const merged = await createWranglerConfig(nuxt, options);
+  const isRemote = Boolean(options.remote || process.env.QARPEO_CF_REMOTE);
+  const hasToken = Boolean(process.env.CLOUDFLARE_API_TOKEN || process.env.CLOUDFLARE_ACCOUNT_ID);
+  if (!isRemote && !hasToken && merged.ai) {
+    delete merged.ai;
+  }
+  await mkdir(buildDir, { recursive: true });
+  await writeFile(configPath, JSON.stringify(merged, null, 2), "utf8");
+  return configPath;
+}
+
+const wrangler = {
+  __proto__: null,
+  createWranglerConfig: createWranglerConfig,
+  generateDevWranglerConfig: generateDevWranglerConfig,
+  resolveProjectName: resolveProjectName
+};
+
+export { getJiti as a, resolveProjectName as b, checkDrizzleVersion as c, findLocalD1Database as d, ensurePackage as e, findSchemaFiles as f, getLocalDatabaseContext as g, createWranglerConfig as h, resolveBindingName as i, findQueueFiles as j, findJobFiles as k, generateDevWranglerConfig as l, applyD1Migrations as m, localDb as n, resolveBinaryPath as r, scanSchemaExports as s, wrangler as w };