create-feedbax 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,173 +1,3407 @@
-import { cp, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
-import { spawn } from 'node:child_process';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const valueFlags = new Set([
-    '--connector',
-    '--identity',
-    '--storage',
-    '--deploy',
-    '--preset',
-    '--package-manager',
-]);
-const booleanFlags = new Set(['--yes', '--no-install', '--no-git']);
-const allowedDeployments = new Set(['cloudflare', 'vercel', 'node']);
-const allowedPackageManagers = new Set(['npm', 'pnpm']);
-const identityMode = (mode) => {
-    if (mode === 'anonymous' || mode === 'email' || mode === 'handoff')
-        return mode;
-    throw new Error(`Identity mode "${mode}" is not supported in Feedbax 0.1.0.`);
-};
-export function resolveCreateOptions(argv) {
-    const values = new Map();
-    let directory;
-    for (let index = 0; index < argv.length; index += 1) {
-        const entry = argv[index];
-        if (valueFlags.has(entry)) {
-            const next = argv[index + 1];
-            if (!next || next.startsWith('-'))
-                throw new Error(`Option ${entry} requires a value.`);
-            values.set(entry, next);
-            index += 1;
+// src/index.ts
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { readFile as readFile2, readdir as readdir2, writeFile as writeFile2 } from "node:fs/promises";
+
+// ../config/src/index.ts
+var rootKeys = [
+  "connected",
+  "product",
+  "theme",
+  "notion",
+  "changelog",
+  "features",
+  "submissions",
+  "turnstile"
+];
+var featureKeys = ["voting", "comments", "changelog"];
+var feedbackPropertyKeys = [
+  "title",
+  "slug",
+  "description",
+  "type",
+  "status",
+  "published",
+  "voteCount",
+  "teamResponse",
+  "releaseNotesUrl",
+  "submitterName",
+  "submitterEmail",
+  "source",
+  "externalId",
+  "editTokenHash",
+  "createdAt",
+  "updatedAt"
+];
+var changelogPropertyKeys = [
+  "title",
+  "slug",
+  "date",
+  "summary",
+  "body",
+  "labels",
+  "image",
+  "published",
+  "createdAt",
+  "updatedAt"
+];
+function defineFeedbax(config) {
+  const value = object(config, "Feedbax configuration");
+  rejectUnknown(value, rootKeys, "Feedbax configuration");
+  const product = object(value.product, "product");
+  rejectUnknown(
+    product,
+    ["name", "description", "logo", "siteUrl", "supportUrl", "privacyUrl"],
+    "product"
+  );
+  const validatedProduct = {
+    name: text(product.name, "product.name"),
+    description: text(product.description, "product.description"),
+    logo: publicUrl(product.logo, "product.logo", true),
+    ...optionalPublicUrl(product, "siteUrl"),
+    ...optionalPublicUrl(product, "supportUrl"),
+    ...optionalPublicUrl(product, "privacyUrl")
+  };
+  let connected;
+  if (value.connected !== void 0) {
+    const input = object(value.connected, "connected");
+    rejectUnknown(
+      input,
+      ["issuer", "loginUrl", "email", "images", "processing"],
+      "connected"
+    );
+    const issuer = publicUrl(input.issuer, "connected.issuer", false);
+    const loginUrl = publicUrl(input.loginUrl, "connected.loginUrl", false);
+    if (!validatedProduct.siteUrl)
+      throw new Error("Connected Profile requires product.siteUrl.");
+    if (new URL(loginUrl).username || new URL(loginUrl).password || new URL(loginUrl).hash)
+      throw new Error(
+        "connected.loginUrl must not contain credentials or a fragment."
+      );
+    let email;
+    if (input.email !== void 0) {
+      const sender = object(input.email, "connected.email");
+      rejectUnknown(
+        sender,
+        ["provider", "from", "endpoint"],
+        "connected.email"
+      );
+      if (!["cloudflare", "resend", "custom"].includes(String(sender.provider)))
+        throw new Error(
+          "connected.email.provider must be cloudflare, resend, or custom."
+        );
+      const from = text(sender.from, "connected.email.from");
+      if (from.length > 254 || !/^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/.test(from))
+        throw new Error(
+          "connected.email.from must be a plain sender email address."
+        );
+      const endpoint = sender.endpoint === void 0 ? void 0 : publicUrl(sender.endpoint, "connected.email.endpoint", false);
+      if (sender.provider === "custom" && !endpoint)
+        throw new Error("Custom email requires connected.email.endpoint.");
+      if (sender.provider !== "custom" && endpoint)
+        throw new Error("Only custom email uses connected.email.endpoint.");
+      if (endpoint && (new URL(endpoint).username || new URL(endpoint).password || new URL(endpoint).hash))
+        throw new Error(
+          "Custom email endpoint must not contain credentials or a fragment."
+        );
+      email = {
+        provider: sender.provider,
+        from,
+        ...endpoint ? { endpoint } : {}
+      };
+    }
+    if (input.images !== void 0 && typeof input.images !== "boolean")
+      throw new Error("connected.images must be true or false.");
+    if (input.processing !== void 0 && input.processing !== "small" && input.processing !== "standard")
+      throw new Error("connected.processing must be small or standard.");
+    connected = {
+      issuer,
+      loginUrl,
+      ...input.processing !== void 0 ? { processing: input.processing } : {},
+      ...email ? { email } : {},
+      ...input.images !== void 0 ? { images: input.images } : {}
+    };
+  }
+  const theme = object(value.theme, "theme");
+  rejectUnknown(theme, ["preset"], "theme");
+  const notion = storage(
+    value.notion,
+    feedbackPropertyKeys,
+    "notion"
+  );
+  const features = object(value.features, "features");
+  rejectUnknown(features, featureKeys, "features");
+  const validatedFeatures = Object.fromEntries(
+    featureKeys.map((key) => {
+      if (typeof features[key] !== "boolean")
+        throw new Error(`features.${key} must be true or false.`);
+      return [key, features[key]];
+    })
+  );
+  const changelog = value.changelog === void 0 ? void 0 : storage(
+    value.changelog,
+    changelogPropertyKeys,
+    "changelog"
+  );
+  if (validatedFeatures.changelog && !changelog)
+    throw new Error(
+      "Changelog is enabled but changelog storage is not configured. Add changelog identifiers and property mappings, or set features.changelog to false."
+    );
+  const submissions = object(value.submissions, "submissions");
+  rejectUnknown(
+    submissions,
+    ["moderation", "maxTitleLength", "maxDescriptionLength"],
+    "submissions"
+  );
+  if (submissions.moderation !== "required")
+    throw new Error('submissions.moderation must be "required".');
+  const turnstile = object(value.turnstile, "turnstile");
+  rejectUnknown(turnstile, ["enabled", "siteKey"], "turnstile");
+  if (typeof turnstile.enabled !== "boolean")
+    throw new Error("turnstile.enabled must be true or false.");
+  const siteKey = turnstile.siteKey === void 0 ? void 0 : text(turnstile.siteKey, "turnstile.siteKey");
+  if (turnstile.enabled && !siteKey)
+    throw new Error("Turnstile is enabled but turnstile.siteKey is missing.");
+  return {
+    product: validatedProduct,
+    ...connected ? { connected } : {},
+    theme: { preset: text(theme.preset, "theme.preset") },
+    notion,
+    ...changelog ? { changelog } : {},
+    features: validatedFeatures,
+    submissions: {
+      moderation: "required",
+      maxTitleLength: positiveInteger(
+        submissions.maxTitleLength,
+        "submissions.maxTitleLength"
+      ),
+      maxDescriptionLength: positiveInteger(
+        submissions.maxDescriptionLength,
+        "submissions.maxDescriptionLength"
+      )
+    },
+    turnstile: { enabled: turnstile.enabled, ...siteKey ? { siteKey } : {} }
+  };
+}
+function storage(value, keys, label) {
+  const input = object(value, label);
+  rejectUnknown(input, ["databaseId", "dataSourceId", "properties"], label);
+  const properties = object(input.properties, `${label}.properties`);
+  rejectUnknown(properties, keys, `${label}.properties`);
+  for (const key of keys) text(properties[key], `${label}.properties.${key}`);
+  return {
+    databaseId: text(input.databaseId, `${label}.databaseId`),
+    dataSourceId: text(input.dataSourceId, `${label}.dataSourceId`),
+    properties: { ...properties }
+  };
+}
+function object(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object.`);
+  return value;
+}
+function text(value, label) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${label} must be a non-empty string.`);
+  return value.trim();
+}
+function positiveInteger(value, label) {
+  if (!Number.isInteger(value) || Number(value) <= 0)
+    throw new Error(`${label} must be a positive integer.`);
+  return Number(value);
+}
+function rejectUnknown(value, allowed, label) {
+  const key = Object.keys(value).find(
+    (candidate) => !allowed.includes(candidate)
+  );
+  if (key) throw new Error(`Unknown ${label} key "${key}".`);
+}
+function optionalPublicUrl(value, key) {
+  return value[key] === void 0 ? {} : { [key]: publicUrl(value[key], `product.${key}`, false) };
+}
+function publicUrl(value, label, allowRelative) {
+  const url = text(value, label);
+  if (allowRelative && url.startsWith("/") && !url.startsWith("//") && !url.includes("\\") && !Array.from(url).some((character) => character.charCodeAt(0) <= 32))
+    return url;
+  try {
+    if (new URL(url).protocol === "https:") return url;
+  } catch {
+  }
+  throw new Error(
+    `${label} must be ${allowRelative ? "root-relative or " : ""}an HTTPS URL.`
+  );
+}
+
+// src/index.ts
+import { basename, join as join2 } from "node:path";
+
+// src/template.ts
+import { createHash } from "node:crypto";
+import { parse } from "jsonc-parser";
+import {
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var ignored = ["node_modules", "dist", ".wrangler", ".dev.vars", ".env"];
+var packagedTemplateDirectory = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  "../template"
+);
+async function assembleFlatTemplate(coreRoot, destination) {
+  const target = resolve(destination);
+  await rm(target, { recursive: true, force: true });
+  await mkdir(join(target, "src/feedbax"), { recursive: true });
+  await copy(join(coreRoot, "apps/portal/src"), join(target, "src"));
+  await copy(join(coreRoot, "apps/portal/public"), join(target, "public"));
+  await copy(
+    join(coreRoot, "apps/portal/migrations"),
+    join(target, "migrations")
+  );
+  await copy(
+    join(coreRoot, "docs/connected-profile.md"),
+    join(target, "CONNECTED.md")
+  );
+  await copy(
+    join(coreRoot, "packages/create-feedbax/docs/installation-readme.md"),
+    join(target, "README.md")
+  );
+  await copy(
+    join(coreRoot, "packages/create-feedbax/docs/installation-agents.md"),
+    join(target, "AGENTS.md")
+  );
+  await copy(
+    join(coreRoot, "packages/feedback/src"),
+    join(target, "src/feedbax/feedback")
+  );
+  await copy(
+    join(coreRoot, "packages/changelog/src"),
+    join(target, "src/feedbax/changelog")
+  );
+  await copy(
+    join(coreRoot, "packages/config/src"),
+    join(target, "src/feedbax/config")
+  );
+  await copy(
+    join(coreRoot, "packages/ui/src"),
+    join(target, "src/components/ui")
+  );
+  const stylesheet = join(target, "src/index.css");
+  await writeFile(
+    stylesheet,
+    (await readFile(stylesheet, "utf8")).replace(
+      '@import "@feedbax/ui/globals.css";',
+      '@import "./components/ui/styles/globals.css";'
+    )
+  );
+  const globals = join(target, "src/components/ui/styles/globals.css");
+  await writeFile(
+    globals,
+    (await readFile(globals, "utf8")).replace(
+      '@source "../../../../apps/**/*.{ts,tsx}";',
+      '@source "../../../**/*.{ts,tsx}";'
+    )
+  );
+  for (const name of ["vite.config.ts"])
+    await copy(join(coreRoot, "apps/portal", name), join(target, name));
+  const components = parse(
+    await readFile(join(coreRoot, "apps/portal/components.json"), "utf8")
+  );
+  components.tailwind.css = "src/index.css";
+  await writeFile(
+    join(target, "components.json"),
+    JSON.stringify(components, null, 2) + "\n"
+  );
+  const wrangler = parse(
+    await readFile(join(coreRoot, "apps/portal/wrangler.jsonc"), "utf8")
+  );
+  delete wrangler.routes;
+  delete wrangler.vars;
+  delete wrangler.account_id;
+  wrangler.name = "feedbax-installation";
+  await writeFile(
+    join(target, "wrangler.jsonc"),
+    JSON.stringify(wrangler, null, 2) + "\n"
+  );
+  await copy(join(coreRoot, "LICENSE"), join(target, "LICENSE"));
+  await copy(
+    join(coreRoot, "eslint.config.mjs"),
+    join(target, "eslint.config.mjs")
+  );
+  await writeFile(
+    join(target, "package.json"),
+    JSON.stringify(await flatManifest(coreRoot), null, 2) + "\n"
+  );
+  await writeFile(
+    join(target, "tsconfig.json"),
+    JSON.stringify(flatTsconfig, null, 2) + "\n"
+  );
+  await writeFile(
+    join(target, "vitest.config.ts"),
+    'import { fileURLToPath } from "node:url";\nimport { defineConfig } from "vitest/config";\nconst src = fileURLToPath(new URL("./src/", import.meta.url));\nexport default defineConfig({ resolve: { alias: [{ find: "@feedbax/feedback", replacement: `${src}feedbax/feedback/index.ts` }, { find: "@feedbax/changelog", replacement: `${src}feedbax/changelog/index.ts` }, { find: "@feedbax/config", replacement: `${src}feedbax/config/index.ts` }, { find: "cloudflare:workers", replacement: `${src}cloudflare-workers-test.ts` }, { find: /^@feedbax\\/ui\\/(.*)$/, replacement: `${src}components/ui/$1` }] } });\n'
+  );
+  const feedbackKeys = [
+    "title",
+    "slug",
+    "description",
+    "type",
+    "status",
+    "published",
+    "voteCount",
+    "teamResponse",
+    "releaseNotesUrl",
+    "submitterName",
+    "submitterEmail",
+    "source",
+    "externalId",
+    "editTokenHash",
+    "createdAt",
+    "updatedAt"
+  ];
+  const changelogKeys = [
+    "title",
+    "slug",
+    "date",
+    "summary",
+    "body",
+    "labels",
+    "image",
+    "published",
+    "createdAt",
+    "updatedAt"
+  ];
+  const fixture = {
+    product: {
+      name: "Feedbax",
+      description: "Share feedback and follow product progress.",
+      logo: "/feedbax-mark.svg"
+    },
+    theme: { preset: "lyra-neutral" },
+    notion: {
+      databaseId: "test-database",
+      dataSourceId: "test-feedback",
+      properties: Object.fromEntries(
+        feedbackKeys.map((key) => [key, `test-${key}`])
+      )
+    },
+    changelog: {
+      databaseId: "test-database",
+      dataSourceId: "test-changelog",
+      properties: Object.fromEntries(
+        changelogKeys.map((key) => [key, `test-${key}`])
+      )
+    },
+    features: { voting: true, comments: true, changelog: true },
+    submissions: {
+      moderation: "required",
+      maxTitleLength: 120,
+      maxDescriptionLength: 5e3
+    },
+    turnstile: { enabled: false }
+  };
+  await writeFile(
+    join(target, "src/feedbax.test-fixture.ts"),
+    `import { defineFeedbax } from "@feedbax/config";
+
+// prettier-ignore
+export default defineFeedbax(${JSON.stringify(fixture, null, 2)});
+`
+  );
+  await writeFile(
+    join(target, "vitest.setup.ts"),
+    'import { vi } from "vitest";\n\nvi.mock("./src/feedbax", () => import("./src/feedbax.test-fixture"));\n'
+  );
+  const testConfigPath = join(target, "vitest.config.ts");
+  await writeFile(
+    testConfigPath,
+    (await readFile(testConfigPath, "utf8")).replace(
+      "defineConfig({ resolve:",
+      'defineConfig({ test: { setupFiles: ["./vitest.setup.ts"] }, resolve:'
+    )
+  );
+  await writeFile(
+    join(target, ".gitignore.template"),
+    ".dev.vars\n.env*\ndist/\n.wrangler/\n*.log\nnode_modules/\n"
+  );
+  await writeFile(
+    join(target, ".npmignore.template"),
+    ".dev.vars\n.env*\ndist/\n.wrangler/\n*.log\n"
+  );
+  await writeFile(
+    join(target, ".prettierignore.template"),
+    "pnpm-lock.yaml\nsrc/routeTree.gen.ts\ntsconfig.json\nvitest.config.ts\n"
+  );
+  const checksum = await templateChecksum(target);
+  await writeFile(join(target, ".feedbax-template.sha256"), `${checksum}
+`);
+  return checksum;
+}
+async function templateChecksum(root) {
+  const hash = createHash("sha256");
+  for (const file of await files(root)) {
+    const name = relative(root, file);
+    if (name === ".feedbax-template.sha256") continue;
+    hash.update(name).update("\0").update(await readFile(file)).update("\0");
+  }
+  return hash.digest("hex");
+}
+async function verifyPackagedTemplate(coreRoot, packaged = packagedTemplateDirectory) {
+  const temporary = `${packaged}.verify-${process.pid}`;
+  try {
+    const expected = await assembleFlatTemplate(coreRoot, temporary);
+    const actual = (await readFile(join(packaged, ".feedbax-template.sha256"), "utf8")).trim();
+    if (actual !== expected || await templateChecksum(packaged) !== actual)
+      throw new Error(
+        "Packaged create-feedbax template is out of sync. Run pnpm template:sync."
+      );
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+async function copyPackagedTemplate(destination, packaged = packagedTemplateDirectory) {
+  const target = resolve(destination);
+  await mkdir(target, { recursive: true });
+  if ((await readdir(target)).length)
+    throw new Error(
+      `Refusing to generate into non-empty destination: ${target}`
+    );
+  await cp(packaged, target, { recursive: true });
+  await renameIgnoreTemplates(target);
+}
+async function renameIgnoreTemplates(target) {
+  const { rename } = await import("node:fs/promises");
+  for (const name of [".gitignore", ".npmignore", ".prettierignore"])
+    await rename(join(target, `${name}.template`), join(target, name));
+}
+async function flatManifest(coreRoot) {
+  const packageFiles = [
+    "apps/portal",
+    "packages/ui",
+    "packages/config",
+    "packages/feedback",
+    "packages/changelog"
+  ];
+  const manifests = await Promise.all(
+    packageFiles.map(
+      async (path) => JSON.parse(await readFile(join(coreRoot, path, "package.json"), "utf8"))
+    )
+  );
+  const workspace = await readFile(
+    join(coreRoot, "pnpm-workspace.yaml"),
+    "utf8"
+  );
+  const catalog = Object.fromEntries(
+    [...workspace.matchAll(/^ {2}("?[^"\s:]+"?): (.+)$/gm)].map((match) => [
+      match[1].replaceAll('"', ""),
+      match[2]
+    ])
+  );
+  const collect = (section) => Object.fromEntries(
+    manifests.flatMap((manifest) => Object.entries(manifest[section] ?? {})).filter(([name]) => !name.startsWith("@feedbax/")).map(([name, version2]) => [
+      name,
+      version2 === "catalog:" ? catalog[name] : version2
+    ])
+  );
+  return {
+    name: "feedbax-installation",
+    version: JSON.parse(
+      await readFile(join(coreRoot, "packages/feedbax/package.json"), "utf8")
+    ).version,
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "vite dev",
+      build: "vite build",
+      test: "vitest run",
+      "type-check": "tsr generate && tsc --noEmit",
+      lint: "eslint .",
+      "format:check": "prettier --check .",
+      deploy: "feedbax deploy",
+      "deploy:dry-run": "wrangler deploy --dry-run"
+    },
+    dependencies: collect("dependencies"),
+    devDependencies: {
+      ...collect("devDependencies"),
+      "@eslint/js": "10.0.1",
+      "@shadcn/lint": "0.2.1",
+      "@types/node": "22.20.1",
+      feedbax: JSON.parse(
+        await readFile(join(coreRoot, "packages/feedbax/package.json"), "utf8")
+      ).version,
+      eslint: "10.8.1",
+      globals: "17.11.0",
+      prettier: "3.9.6",
+      "typescript-eslint": "8.67.0",
+      vitest: "4.1.11"
+    },
+    pnpm: { onlyBuiltDependencies: ["esbuild"] },
+    engines: { node: ">=22.14.0" },
+    packageManager: "pnpm@10.29.3",
+    license: "Apache-2.0"
+  };
+}
+var flatTsconfig = {
+  include: ["src/**/*.ts", "src/**/*.tsx"],
+  compilerOptions: {
+    target: "ES2022",
+    jsx: "react-jsx",
+    module: "ESNext",
+    lib: ["ES2022", "DOM", "DOM.Iterable"],
+    types: ["vite/client", "node"],
+    moduleResolution: "bundler",
+    allowImportingTsExtensions: true,
+    noEmit: true,
+    skipLibCheck: true,
+    strict: true,
+    paths: {
+      "@/*": ["./src/*"],
+      "@feedbax/feedback": ["./src/feedbax/feedback/index.ts"],
+      "@feedbax/changelog": ["./src/feedbax/changelog/index.ts"],
+      "@feedbax/config": ["./src/feedbax/config/index.ts"],
+      "@feedbax/ui/*": ["./src/components/ui/*"],
+      "@feedbax/ui/globals.css": ["./src/components/ui/styles/globals.css"]
+    }
+  }
+};
+async function copy(from, to) {
+  await cp(from, to, {
+    recursive: true,
+    filter: (source) => !ignored.some((entry) => source.includes(`/${entry}`))
+  });
+}
+async function files(root) {
+  const entries = await readdir(root);
+  const result = [];
+  for (const entry of entries.sort()) {
+    const path = join(root, entry);
+    if ((await stat(path)).isDirectory()) result.push(...await files(path));
+    else result.push(path);
+  }
+  return result;
+}
+
+// ../feedback/src/notion-request.ts
+var MAX_ATTEMPTS = 3;
+var BASE_BACKOFF_MILLISECONDS = 250;
+var MAX_BACKOFF_MILLISECONDS = 2e3;
+async function requestNotion(input, init = {}, {
+  request,
+  retry = {},
+  operation
+}) {
+  const sleep = retry.sleep ?? defaultSleep;
+  const random = retry.random ?? Math.random;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    const response = await request(input, init);
+    if (!isRetryableNotionFailure(response.status, operation)) return response;
+    if (attempt === MAX_ATTEMPTS) {
+      throw new Error(
+        `Notion request failed after ${MAX_ATTEMPTS} attempts (${response.status}).`
+      );
+    }
+    await sleep(retryDelayMilliseconds(response, attempt, random));
+  }
+  throw new Error("Notion request retry loop ended unexpectedly.");
+}
+function isRetryableNotionFailure(status, operation) {
+  return status === 429 || status === 529 && operation === "idempotent";
+}
+function retryDelayMilliseconds(response, attempt, random) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  }
+  return exponentialDelayMilliseconds(attempt, random);
+}
+function exponentialDelayMilliseconds(attempt, random) {
+  const ceiling = Math.min(
+    BASE_BACKOFF_MILLISECONDS * 2 ** (attempt - 1),
+    MAX_BACKOFF_MILLISECONDS
+  );
+  return Math.round(ceiling / 2 + random() * (ceiling / 2));
+}
+async function defaultSleep(milliseconds) {
+  await new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+
+// ../feedback/src/notion-data-source.ts
+var NOTION_API_URL = "https://api.notion.com/v1";
+var NOTION_API_VERSION = "2026-03-11";
+var canonicalProperties = {
+  title: { name: "Title", type: "title", schema: { title: {} } },
+  slug: { name: "Slug", type: "rich_text", schema: { rich_text: {} } },
+  description: {
+    name: "Description",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  type: {
+    name: "Type",
+    type: "select",
+    schema: {
+      select: {
+        options: [
+          { name: "Feature Request" },
+          { name: "Bug Report" },
+          { name: "General Feedback" }
+        ]
+      }
+    }
+  },
+  status: {
+    name: "Status",
+    type: "select",
+    schema: {
+      select: {
+        options: [
+          { name: "New" },
+          { name: "Reviewing" },
+          { name: "Planned" },
+          { name: "In Progress" },
+          { name: "Shipped" },
+          { name: "Closed" }
+        ]
+      }
+    }
+  },
+  published: {
+    name: "Published",
+    type: "checkbox",
+    schema: { checkbox: {} }
+  },
+  voteCount: {
+    name: "Vote Count",
+    type: "number",
+    schema: { number: { format: "number" } }
+  },
+  teamResponse: {
+    name: "Team Response",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  releaseNotesUrl: {
+    name: "Release Notes URL",
+    type: "url",
+    schema: { url: {} }
+  },
+  submitterName: {
+    name: "Submitter Name",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  submitterEmail: {
+    name: "Submitter Email",
+    type: "email",
+    schema: { email: {} }
+  },
+  source: {
+    name: "Source",
+    type: "select",
+    schema: {
+      select: {
+        options: [{ name: "Portal" }, { name: "API" }, { name: "Team" }]
+      }
+    }
+  },
+  externalId: {
+    name: "External ID",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  editTokenHash: {
+    name: "Edit Token Hash",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  createdAt: {
+    name: "Created At",
+    type: "created_time",
+    schema: { created_time: {} }
+  },
+  updatedAt: {
+    name: "Updated At",
+    type: "last_edited_time",
+    schema: { last_edited_time: {} }
+  }
+};
+var feedbackWorkflowProperties = {
+  Owner: { people: {} },
+  Priority: {
+    select: {
+      options: [
+        { name: "Urgent" },
+        { name: "High" },
+        { name: "Medium" },
+        { name: "Low" }
+      ]
+    }
+  },
+  "Strategic Theme": { multi_select: { options: [] } },
+  "Participant Segment": { multi_select: { options: [] } },
+  Impact: {
+    select: {
+      options: [{ name: "High" }, { name: "Medium" }, { name: "Low" }]
+    }
+  },
+  Effort: {
+    select: {
+      options: [{ name: "Small" }, { name: "Medium" }, { name: "Large" }]
+    }
+  },
+  "Decision Note": { rich_text: {} },
+  "Needs Follow-up": { checkbox: {} }
+};
+async function createNotionFeedbackDataSource({
+  token,
+  parentPageId,
+  request = fetch,
+  retry
+}) {
+  const response = await requestNotion(
+    `${NOTION_API_URL}/databases`,
+    {
+      method: "POST",
+      headers: notionHeaders(token),
+      body: JSON.stringify({
+        parent: { type: "page_id", page_id: parentPageId },
+        title: [{ type: "text", text: { content: "Feedback" } }],
+        initial_data_source: {
+          properties: {
+            ...Object.fromEntries(
+              Object.values(canonicalProperties).map(({ name, schema }) => [
+                name,
+                schema
+              ])
+            ),
+            ...feedbackWorkflowProperties
+          }
+        }
+      })
+    },
+    { request, retry, operation: "create" }
+  );
+  const database = await readNotionResponse(response);
+  if (typeof database.id !== "string") {
+    throw new Error("Notion did not return the created Feedback database.");
+  }
+  const dataSourceId = firstDataSourceId(database);
+  const dataSourceResponse = await requestNotion(
+    `${NOTION_API_URL}/data_sources/${dataSourceId}`,
+    { method: "GET", headers: notionHeaders(token) },
+    { request, retry, operation: "idempotent" }
+  );
+  const dataSource = await readNotionResponse(dataSourceResponse);
+  return configurationFromCanonicalNames(dataSource, database.id);
+}
+async function createFeedbackWorkflowViews({
+  token,
+  databaseId,
+  dataSourceId,
+  propertyIds,
+  request = fetch
+}) {
+  const views = [
+    {
+      name: "Inbox",
+      type: "table",
+      filter: selectFilter(propertyIds.status, "New"),
+      sorts: [{ property: propertyIds.createdAt, direction: "descending" }]
+    },
+    {
+      name: "Reviewing",
+      type: "table",
+      filter: selectFilter(propertyIds.status, "Reviewing"),
+      sorts: [{ property: propertyIds.updatedAt, direction: "descending" }]
+    },
+    {
+      name: "Prioritization",
+      type: "table",
+      filter: {
+        or: [
+          selectFilter(propertyIds.status, "Reviewing"),
+          selectFilter(propertyIds.status, "Planned")
+        ]
+      },
+      sorts: [
+        { property: "Priority", direction: "ascending" },
+        { property: propertyIds.voteCount, direction: "descending" }
+      ]
+    },
+    {
+      name: "Follow-up",
+      type: "table",
+      filter: { property: "Needs Follow-up", checkbox: { equals: true } }
+    },
+    {
+      name: "Roadmap",
+      type: "board",
+      filter: {
+        or: ["Planned", "In Progress", "Shipped"].map(
+          (status) => selectFilter(propertyIds.status, status)
+        )
+      },
+      configuration: {
+        type: "board",
+        group_by: {
+          type: "select",
+          property_id: propertyIds.status,
+          group_by: "option",
+          sort: { type: "manual" }
+        }
+      }
+    },
+    {
+      name: "Shipped",
+      type: "table",
+      filter: selectFilter(propertyIds.status, "Shipped"),
+      sorts: [{ property: propertyIds.updatedAt, direction: "descending" }]
+    }
+  ];
+  for (const view of views) {
+    const response = await requestNotion(
+      `${NOTION_API_URL}/views`,
+      {
+        method: "POST",
+        headers: notionHeaders(token),
+        body: JSON.stringify({
+          database_id: databaseId,
+          data_source_id: dataSourceId,
+          ...view
+        })
+      },
+      { request, operation: "create" }
+    );
+    await readNotionResponse(response);
+  }
+}
+function selectFilter(property, value) {
+  return { property, select: { equals: value } };
+}
+async function validateNotionFeedbackDataSource({
+  token,
+  dataSourceId,
+  propertyIds,
+  request = fetch,
+  retry
+}) {
+  const response = await requestNotion(
+    `${NOTION_API_URL}/data_sources/${dataSourceId}`,
+    {
+      method: "GET",
+      headers: notionHeaders(token)
+    },
+    { request, retry, operation: "idempotent" }
+  );
+  const dataSource = await readNotionResponse(response);
+  const properties = dataSource.properties;
+  if (typeof dataSource.id !== "string" || !isPropertyMap(properties)) {
+    throw new Error(
+      "Notion returned an invalid Feedback Data Source response."
+    );
+  }
+  const propertiesById = new Map(
+    Object.values(properties).filter(
+      (property) => Boolean(property) && typeof property.id === "string"
+    ).map((property) => [property.id, property])
+  );
+  const repairs = [];
+  for (const [key, { name, type }] of Object.entries(canonicalProperties)) {
+    const configuredId = propertyIds[key];
+    const property = propertiesById.get(configuredId);
+    if (!property) {
+      repairs.push(
+        `Restore the "${name}" property with ID "${configuredId}" and type "${type}", then update the configured property ID if Notion assigns a new one.`
+      );
+    } else if (property.type !== type) {
+      repairs.push(
+        `Change the property configured as "${name}" (ID "${configuredId}") from "${String(property.type)}" to "${type}", or restore a ${type} property and configure its ID.`
+      );
+    }
+  }
+  if (repairs.length > 0) {
+    throw new Error(repairs.join("\n"));
+  }
+  return {
+    databaseId: databaseIdFromDataSource(dataSource),
+    dataSourceId,
+    propertyIds: { ...propertyIds }
+  };
+}
+function notionHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": NOTION_API_VERSION
+  };
+}
+async function readNotionResponse(response) {
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      `Notion rejected the Feedback Data Source request (${response.status}).`
+    );
+  }
+  if (!body || typeof body !== "object") {
+    throw new Error(
+      "Notion returned an invalid Feedback Data Source response."
+    );
+  }
+  return body;
+}
+function firstDataSourceId(database) {
+  const dataSources = Reflect.get(database, "data_sources");
+  const firstDataSource = Array.isArray(dataSources) ? dataSources[0] : void 0;
+  const id = firstDataSource && typeof firstDataSource === "object" ? Reflect.get(firstDataSource, "id") : void 0;
+  if (typeof id !== "string") {
+    throw new Error("Notion did not return the created Feedback Data Source.");
+  }
+  return id;
+}
+function configurationFromCanonicalNames(dataSource, databaseId) {
+  const properties = dataSource.properties;
+  if (typeof dataSource.id !== "string" || !isPropertyMap(properties)) {
+    throw new Error(
+      "Notion returned an invalid Feedback Data Source response."
+    );
+  }
+  return {
+    databaseId,
+    dataSourceId: dataSource.id,
+    propertyIds: Object.fromEntries(
+      Object.entries(canonicalProperties).map(([key, { name }]) => {
+        const property = properties[name];
+        if (!property || typeof property.id !== "string") {
+          throw new Error(
+            `Notion did not return the required ${name} property.`
+          );
         }
-        else if (booleanFlags.has(entry))
-            continue;
-        else if (entry.startsWith('-'))
-            throw new Error(`Unknown option ${entry}.`);
-        else if (directory)
-            throw new Error(`Unexpected argument ${entry}.`);
-        else
-            directory = entry;
-    }
-    const value = (name) => values.get(name);
-    directory ??= 'my-feedback';
-    const connector = value('--connector') ?? 'notion';
-    const storage = value('--storage') ?? 'notion';
-    if (connector !== 'notion')
-        throw new Error(`Connector "${connector}" is not supported in Feedbax 0.1.0.`);
-    if (storage !== 'notion')
-        throw new Error(`Storage "${storage}" is deferred until after Feedbax 0.1.0.`);
-    const identity = identityMode(value('--identity') ?? 'email');
-    const deploy = (value('--deploy') ?? 'cloudflare');
-    if (!allowedDeployments.has(deploy))
-        throw new Error(`Deployment "${deploy}" is not supported.`);
-    const packageManager = (value('--package-manager') ??
-        'pnpm');
-    if (!allowedPackageManagers.has(packageManager))
-        throw new Error(`Package manager "${packageManager}" is not supported.`);
-    return {
-        directory,
-        identity,
-        deploy,
-        packageManager,
-        preset: value('--preset') ?? 'feedbax-default',
-        install: !argv.includes('--no-install'),
-        git: !argv.includes('--no-git'),
+        return [key, property.id];
+      })
+    )
+  };
+}
+function databaseIdFromDataSource(dataSource) {
+  const parent = dataSource.parent;
+  const databaseId = parent && typeof parent === "object" ? Reflect.get(parent, "database_id") : void 0;
+  if (typeof databaseId !== "string") {
+    throw new Error(
+      "Notion did not return the Feedback Data Source parent database."
+    );
+  }
+  return databaseId;
+}
+function isPropertyMap(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/entity.js
+var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(
+      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/column.js
+var Column = class {
+  constructor(table, config) {
+    this.table = table;
+    this.config = config;
+    this.name = config.name;
+    this.keyAsName = config.keyAsName;
+    this.notNull = config.notNull;
+    this.default = config.default;
+    this.defaultFn = config.defaultFn;
+    this.onUpdateFn = config.onUpdateFn;
+    this.hasDefault = config.hasDefault;
+    this.primary = config.primaryKey;
+    this.isUnique = config.isUnique;
+    this.uniqueName = config.uniqueName;
+    this.uniqueType = config.uniqueType;
+    this.dataType = config.dataType;
+    this.columnType = config.columnType;
+    this.generated = config.generated;
+    this.generatedIdentity = config.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: void 0,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType,
+      columnType,
+      generated: void 0
+    };
+  }
+  /**
+   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+   *
+   * @example
+   * ```ts
+   * const users = pgTable('users', {
+   * 	id: integer('id').$type<UserId>().primaryKey(),
+   * 	details: json('details').$type<UserDetails>().notNull(),
+   * });
+   * ```
+   */
+  $type() {
+    return this;
+  }
+  /**
+   * Adds a `not null` clause to the column definition.
+   *
+   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+   */
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  /**
+   * Adds a `default <value>` clause to the column definition.
+   *
+   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+   *
+   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+   */
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Adds a dynamic default value to the column.
+   * The function will be called when the row is inserted, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $defaultFn}.
+   */
+  $default = this.$defaultFn;
+  /**
+   * Adds a dynamic update value to the column.
+   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $onUpdateFn}.
+   */
+  $onUpdate = this.$onUpdateFn;
+  /**
+   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+   *
+   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+   */
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(name) {
+    if (this.config.name !== "") return;
+    this.config.name = name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/table.utils.js
+var TableName = /* @__PURE__ */ Symbol.for("drizzle:Name");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+  static [entityKind] = "PgForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate = "no action";
+  /** @internal */
+  _onDelete = "no action";
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
     };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action === void 0 ? "no action" : action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action === void 0 ? "no action" : action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+};
+var ForeignKey = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "PgForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
 }
-export async function resolveInteractiveCreateOptions(argv, prompt) {
-    if (argv.includes('--yes'))
-        return resolveCreateOptions(argv);
-    const prompted = [...argv];
-    const ask = async (flag, question, defaultValue) => {
-        if (argv.includes(flag))
-            return;
-        const answer = (await prompt(question, defaultValue)).trim() || defaultValue;
-        prompted.push(flag, answer);
+var UniqueConstraintBuilder = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "PgUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  nullsNotDistinctConfig = false;
+  nullsNotDistinct() {
+    this.nullsNotDistinctConfig = true;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+  }
+};
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+};
+var UniqueConstraint = class {
+  constructor(table, columns, nullsNotDistinct, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+    this.nullsNotDistinct = nullsNotDistinct;
+  }
+  static [entityKind] = "PgUniqueConstraint";
+  columns;
+  name;
+  nullsNotDistinct = false;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom; i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "," || char === "}") {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+    }
+  }
+  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom) {
+        result.push("");
+      }
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}") {
+      return [result, i + 1];
+    }
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
+  }
+  return [result, i];
+}
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
+}
+function makePgArray(array) {
+  return `{${array.map((item) => {
+    if (Array.isArray(item)) {
+      return makePgArray(item);
+    }
+    if (typeof item === "string") {
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return `${item}`;
+  }).join(",")}}`;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+  foreignKeyConfigs = [];
+  static [entityKind] = "PgColumnBuilder";
+  array(size) {
+    return new PgArrayBuilder(this.config.name, this, size);
+  }
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
+  }
+  generatedAlwaysAs(as) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: "stored"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return iife(
+        (ref2, actions2) => {
+          const builder = new ForeignKeyBuilder(() => {
+            const foreignColumn = ref2();
+            return { columns: [column], foreignColumns: [foreignColumn] };
+          });
+          if (actions2.onUpdate) {
+            builder.onUpdate(actions2.onUpdate);
+          }
+          if (actions2.onDelete) {
+            builder.onDelete(actions2.onDelete);
+          }
+          return builder.build(table);
+        },
+        ref,
+        actions
+      );
+    });
+  }
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new ExtraConfigColumn(table, this.config);
+  }
+};
+var PgColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: void 0
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  /**
+   * ### PostgreSQL documentation quote
+   *
+   * > An operator class with optional parameters can be specified for each column of an index.
+   * The operator class identifies the operators to be used by the index for that column.
+   * For example, a B-tree index on four-byte integers would use the int4_ops class;
+   * this operator class includes comparison functions for four-byte integers.
+   * In practice the default operator class for the column's data type is usually sufficient.
+   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+   * For example, we might want to sort a complex-number data type either by absolute value or by real part.
+   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+   * More information about operator classes check:
+   *
+   * ### Useful links
+   * https://www.postgresql.org/docs/current/sql-createindex.html
+   *
+   * https://www.postgresql.org/docs/current/indexes-opclass.html
+   *
+   * https://www.postgresql.org/docs/current/xindex.html
+   *
+   * ### Additional types
+   * If you have the `pg_vector` extension installed in your database, you can use the
+   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+   *
+   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+   *
+   * @param opClass
+   * @returns
+   */
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+};
+var IndexedColumn = class {
+  static [entityKind] = "IndexedColumn";
+  constructor(name, keyAsName, type, indexConfig) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+  name;
+  keyAsName;
+  type;
+  indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgArrayBuilder";
+  constructor(name, baseBuilder, size) {
+    super(name, "array", "PgArray");
+    this.config.baseBuilder = baseBuilder;
+    this.config.size = size;
+  }
+  /** @internal */
+  build(table) {
+    const baseColumn = this.config.baseBuilder.build(table);
+    return new PgArray(
+      table,
+      this.config,
+      baseColumn
+    );
+  }
+};
+var PgArray = class _PgArray extends PgColumn {
+  constructor(table, config, baseColumn, range) {
+    super(table, config);
+    this.baseColumn = baseColumn;
+    this.range = range;
+    this.size = config.size;
+  }
+  size;
+  static [entityKind] = "PgArray";
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      value = parsePgArray(value);
+    }
+    return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+  }
+  mapToDriverValue(value, isNestedArray = false) {
+    const a = value.map(
+      (v) => v === null ? null : is(this.baseColumn, _PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v)
+    );
+    if (isNestedArray) return a;
+    return makePgArray(a);
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/pg-core/columns/enum.js
+var PgEnumObjectColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgEnumObjectColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumObjectColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumObjectColumn(
+      table,
+      this.config
+    );
+  }
+};
+var PgEnumObjectColumn = class extends PgColumn {
+  static [entityKind] = "PgEnumObjectColumn";
+  enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+var isPgEnumSym = /* @__PURE__ */ Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgEnumColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumColumn(
+      table,
+      this.config
+    );
+  }
+};
+var PgEnumColumn = class extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+  static [entityKind] = "Subquery";
+  constructor(sql2, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
     };
-    await ask('--identity', 'Identity (anonymous, email, handoff)', 'email');
-    await ask('--deploy', 'Deployment (cloudflare, vercel, node)', 'cloudflare');
-    await ask('--package-manager', 'Package manager (pnpm, npm)', 'pnpm');
-    await ask('--preset', 'shadcn preset', 'feedbax-default');
-    return resolveCreateOptions(prompted);
-}
-async function assertEmpty(path) {
-    try {
-        if ((await readdir(path)).length > 0)
-            throw new Error(`Target directory is not empty: ${path}`);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-    }
-}
-async function replaceInTree(path, replacements) {
-    for (const entry of await readdir(path)) {
-        const target = join(path, entry);
-        if ((await stat(target)).isDirectory())
-            await replaceInTree(target, replacements);
-        else {
-            let content = await readFile(target, 'utf8');
-            for (const [token, replacement] of Object.entries(replacements))
-                content = content.replaceAll(token, replacement);
-            await writeFile(target, content);
+  }
+  // getSQL(): SQL<unknown> {
+  // 	return new SQL([this]);
+  // }
+};
+var WithSubquery = class extends Subquery {
+  static [entityKind] = "WithSubquery";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/version.js
+var version = "0.45.2";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife(
+      (otel2, rawTracer2) => rawTracer2.startActiveSpan(
+        name,
+        (span) => {
+          try {
+            return fn(span);
+          } catch (e) {
+            span.setStatus({
+              code: otel2.SpanStatusCode.ERROR,
+              message: e instanceof Error ? e.message : "Unknown error"
+              // eslint-disable-line no-instanceof/no-instanceof
+            });
+            throw e;
+          } finally {
+            span.end();
+          }
         }
+      ),
+      otel,
+      rawTracer
+    );
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/table.js
+var Schema = /* @__PURE__ */ Symbol.for("drizzle:Schema");
+var Columns = /* @__PURE__ */ Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = /* @__PURE__ */ Symbol.for("drizzle:OriginalName");
+var BaseName = /* @__PURE__ */ Symbol.for("drizzle:BaseName");
+var IsAlias = /* @__PURE__ */ Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+  static [entityKind] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  /**
+   * @internal
+   * Can be changed if the table is aliased.
+   */
+  [TableName];
+  /**
+   * @internal
+   * Used to store the original name of the table, before any aliasing.
+   */
+  [OriginalName];
+  /** @internal */
+  [Schema];
+  /** @internal */
+  [Columns];
+  /** @internal */
+  [ExtraConfigColumns];
+  /**
+   *  @internal
+   * Used to store the table name before the transformation via the `tableCreator` functions.
+   */
+  [BaseName];
+  /** @internal */
+  [IsAlias] = false;
+  /** @internal */
+  [IsDrizzleTable] = true;
+  /** @internal */
+  [ExtraConfigBuilder] = void 0;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
+function isSQLWrapper(value) {
+  return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
     }
+  }
+  return result;
 }
-const run = (command, args, cwd) => new Promise((resolvePromise, reject) => {
-    const child = spawn(command, args, { cwd, stdio: 'inherit', shell: false });
-    child.once('error', reject);
-    child.once('exit', (code) => code === 0
-        ? resolvePromise()
-        : reject(new Error(`${command} ${args.join(' ')} failed with ${code}.`)));
-});
-export async function createProject(options) {
-    const destination = resolve(options.directory);
-    await assertEmpty(destination);
-    await mkdir(dirname(destination), { recursive: true });
-    const packageDirectory = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        resolve(packageDirectory, '../template'),
-        resolve(packageDirectory, '../../../templates/default'),
+var StringChunk = class {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var SQL = class _SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) {
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        this.usedTables.push(
+          schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]
+        );
+      }
+    }
+  }
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  /** @internal */
+  usedTables = [];
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === void 0) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config);
+      }
+      if (is(chunk, _SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, _SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, _SQL.Aliased) && chunk.fieldAlias !== void 0) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === void 0) {
+      return this;
+    }
+    return new _SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(condition) {
+    return condition ? this : void 0;
+  }
+};
+var Name = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+var Param = class {
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join3(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== void 0) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join3;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var IsDrizzleView = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleView");
+var View = class {
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  /** @internal */
+  [IsDrizzleView] = true;
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+var ForeignKeyBuilder2 = class {
+  static [entityKind] = "SQLiteForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate;
+  /** @internal */
+  _onDelete;
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey2(table, this);
+  }
+};
+var ForeignKey2 = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
     ];
-    let template;
-    for (const candidate of candidates) {
-        try {
-            if ((await stat(candidate)).isDirectory()) {
-                template = candidate;
-                break;
-            }
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName2(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder2 = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "SQLiteUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint2(table, this.columns, this.name);
+  }
+};
+var UniqueOnConstraintBuilder2 = class {
+  static [entityKind] = "SQLiteUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder2(columns, this.name);
+  }
+};
+var UniqueConstraint2 = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName2(this.table, this.columns.map((column) => column.name));
+  }
+  static [entityKind] = "SQLiteUniqueConstraint";
+  columns;
+  name;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/common.js
+var SQLiteColumnBuilder = class extends ColumnBuilder {
+  static [entityKind] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    return this;
+  }
+  generatedAlwaysAs(as, config) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: config?.mode ?? "virtual"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return ((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder2(() => {
+          const foreignColumn = ref2();
+          return { columns: [column], foreignColumns: [foreignColumn] };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
         }
-        catch {
-            continue;
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
         }
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+};
+var SQLiteColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName2(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "SQLiteColumn";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+};
+var SQLiteBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return BigInt(buf.toString("utf8"));
+    }
+    return BigInt(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+};
+var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobJson(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteBlobJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return JSON.parse(buf.toString("utf8"));
+    }
+    return JSON.parse(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+};
+var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+};
+var SQLiteBlobBuffer = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  mapFromDriverValue(value) {
+    if (Buffer.isBuffer(value)) {
+      return value;
+    }
+    return Buffer.from(value);
+  }
+  getSQLType() {
+    return "blob";
+  }
+};
+function blob(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "json") {
+    return new SQLiteBlobJsonBuilder(name);
+  }
+  if (config?.mode === "bigint") {
+    return new SQLiteBigIntBuilder(name);
+  }
+  return new SQLiteBlobBufferBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteCustomColumn(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteCustomColumn = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+};
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(
+      name,
+      config,
+      customTypeParams
+    );
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBaseIntegerBuilder";
+  constructor(name, dataType, columnType) {
+    super(name, dataType, columnType);
+    this.config.autoIncrement = false;
+  }
+  primaryKey(config) {
+    if (config?.autoIncrement) {
+      this.config.autoIncrement = true;
+    }
+    this.config.hasDefault = true;
+    return super.primaryKey();
+  }
+};
+var SQLiteBaseInteger = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+};
+var SQLiteIntegerBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteInteger");
+  }
+  build(table) {
+    return new SQLiteInteger(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteInteger = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteInteger";
+};
+var SQLiteTimestampBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteTimestampBuilder";
+  constructor(name, mode) {
+    super(name, "date", "SQLiteTimestamp");
+    this.config.mode = mode;
+  }
+  /**
+   * @deprecated Use `default()` with your own expression instead.
+   *
+   * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
+   */
+  defaultNow() {
+    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(table) {
+    return new SQLiteTimestamp(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteTimestamp = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    if (this.config.mode === "timestamp") {
+      return new Date(value * 1e3);
+    }
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    const unix = value.getTime();
+    if (this.config.mode === "timestamp") {
+      return Math.floor(unix / 1e3);
+    }
+    return unix;
+  }
+};
+var SQLiteBooleanBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteBooleanBuilder";
+  constructor(name, mode) {
+    super(name, "boolean", "SQLiteBoolean");
+    this.config.mode = mode;
+  }
+  build(table) {
+    return new SQLiteBoolean(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteBoolean = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    return Number(value) === 1;
+  }
+  mapToDriverValue(value) {
+    return value ? 1 : 0;
+  }
+};
+function integer(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
+    return new SQLiteTimestampBuilder(name, config.mode);
+  }
+  if (config?.mode === "boolean") {
+    return new SQLiteBooleanBuilder(name, config.mode);
+  }
+  return new SQLiteIntegerBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumeric(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteNumeric = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  mapFromDriverValue(value) {
+    if (typeof value === "string") return value;
+    return String(value);
+  }
+  getSQLType() {
+    return "numeric";
+  }
+};
+var SQLiteNumericNumberBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericNumberBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteNumericNumber");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericNumber(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteNumericNumber = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericNumber";
+  mapFromDriverValue(value) {
+    if (typeof value === "number") return value;
+    return Number(value);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+};
+var SQLiteNumericBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteNumericBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericBigInt(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteNumericBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+};
+function numeric(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  const mode = config?.mode;
+  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/real.js
+var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteReal");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+};
+var SQLiteReal = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+};
+function real(name) {
+  return new SQLiteRealBuilder(name ?? "");
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/text.js
+var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name, config) {
+    super(name, "string", "SQLiteText");
+    this.config.enumValues = config.enum;
+    this.config.length = config.length;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteText(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteText = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  length = this.config.length;
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+};
+var SQLiteTextJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteTextJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteTextJson(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteTextJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(value);
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+};
+function text2(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "json") {
+    return new SQLiteTextJsonBuilder(name);
+  }
+  return new SQLiteTextBuilder(name, config);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text: text2
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/table.js
+var InlineForeignKeys = /* @__PURE__ */ Symbol.for("drizzle:SQLiteInlineForeignKeys");
+var SQLiteTable = class extends Table {
+  static [entityKind] = "SQLiteTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  /** @internal */
+  [Table.Symbol.Columns];
+  /** @internal */
+  [InlineForeignKeys] = [];
+  /** @internal */
+  [Table.Symbol.ExtraConfigBuilder] = void 0;
+};
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new SQLiteTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(
+    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+      const colBuilder = colBuilderBase;
+      colBuilder.setName(name2);
+      const column = colBuilder.build(rawTable);
+      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+      return [name2, column];
+    })
+  );
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) {
+    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return table;
+}
+var sqliteTable = (name, columns, extraConfig) => {
+  return sqliteTableBase(name, columns, extraConfig);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20261014.1_kysely@0.29.6/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config) {
+  if (config[0].columns) {
+    return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+  }
+  return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+  static [entityKind] = "SQLitePrimaryKeyBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  name;
+  constructor(columns, name) {
+    this.columns = columns;
+    this.name = name;
+  }
+  /** @internal */
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+};
+var PrimaryKey = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name;
+  }
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+};
+
+// ../feedback/src/connected.ts
+var participants = sqliteTable("participants", {
+  subject: text2("subject").primaryKey(),
+  displayName: text2("display_name").notNull()
+});
+var contacts = sqliteTable("participant_contacts", {
+  subject: text2("subject").primaryKey(),
+  email: text2("email"),
+  emailEnabled: integer("email_enabled").notNull().default(0)
+});
+var nonces = sqliteTable("identity_nonces", {
+  nonce: text2("nonce").primaryKey(),
+  expiresAt: integer("expires_at").notNull()
+});
+var sessions = sqliteTable("participant_sessions", {
+  tokenHash: text2("token_hash").primaryKey(),
+  subject: text2("subject").notNull().references(() => participants.subject),
+  expiresAt: integer("expires_at").notNull()
+});
+var votes = sqliteTable(
+  "participant_votes",
+  {
+    postSlug: text2("post_slug").notNull(),
+    subject: text2("subject").notNull().references(() => participants.subject)
+  },
+  (t) => [primaryKey({ columns: [t.postSlug, t.subject] })]
+);
+var attribution = sqliteTable("comment_attribution", {
+  commentId: text2("comment_id").primaryKey(),
+  subject: text2("subject").notNull().references(() => participants.subject),
+  displayName: text2("display_name").notNull()
+});
+
+// ../feedback/src/images.ts
+var limit = 5 * 1024 * 1024;
+
+// ../feedback/src/index.ts
+var postCreationQueue = Promise.resolve();
+
+// ../changelog/src/notion-changelog.ts
+var NOTION_API_URL2 = "https://api.notion.com/v1";
+var NOTION_API_VERSION2 = "2026-03-11";
+var canonicalProperties2 = {
+  title: { name: "Title", type: "title", schema: { title: {} } },
+  slug: { name: "Slug", type: "rich_text", schema: { rich_text: {} } },
+  date: { name: "Date", type: "date", schema: { date: {} } },
+  summary: {
+    name: "Summary",
+    type: "rich_text",
+    schema: { rich_text: {} }
+  },
+  body: { name: "Body", type: "rich_text", schema: { rich_text: {} } },
+  labels: {
+    name: "Labels",
+    type: "multi_select",
+    schema: { multi_select: { options: [] } }
+  },
+  image: { name: "Image", type: "files", schema: { files: {} } },
+  published: {
+    name: "Published",
+    type: "checkbox",
+    schema: { checkbox: {} }
+  },
+  createdAt: {
+    name: "Created At",
+    type: "created_time",
+    schema: { created_time: {} }
+  },
+  updatedAt: {
+    name: "Updated At",
+    type: "last_edited_time",
+    schema: { last_edited_time: {} }
+  }
+};
+async function createNotionChangelogDataSource({
+  token,
+  databaseId,
+  request = fetch
+}) {
+  const response = await request(`${NOTION_API_URL2}/data_sources`, {
+    method: "POST",
+    headers: notionHeaders2(token),
+    body: JSON.stringify({
+      parent: { database_id: databaseId },
+      title: [{ type: "text", text: { content: "Changelog" } }],
+      properties: Object.fromEntries(
+        Object.values(canonicalProperties2).map(({ name, schema }) => [
+          name,
+          schema
+        ])
+      )
+    })
+  });
+  return configurationFromResponse(
+    await readObject(response, "Changelog Data Source"),
+    databaseId
+  );
+}
+async function validateNotionChangelogDataSource({
+  token,
+  dataSourceId,
+  propertyIds,
+  request = fetch
+}) {
+  const response = await request(
+    `${NOTION_API_URL2}/data_sources/${dataSourceId}`,
+    { headers: notionHeaders2(token) }
+  );
+  const dataSource = await readObject(response, "Changelog Data Source");
+  const properties = recordAt(dataSource, "properties");
+  const propertiesById = new Map(
+    Object.values(properties).flatMap((property) => {
+      if (!isRecord(property) || typeof property.id !== "string") return [];
+      return [[property.id, property]];
+    })
+  );
+  const repairs = [];
+  for (const [key, { name, type }] of Object.entries(canonicalProperties2)) {
+    const configuredId = propertyIds[key];
+    const property = propertiesById.get(configuredId);
+    if (!property) {
+      repairs.push(
+        `Restore the "${name}" property with ID "${configuredId}" and type "${type}", then update the configured property ID if Notion assigns a new one.`
+      );
+    } else if (property.type !== type) {
+      repairs.push(
+        `Change the property configured as "${name}" (ID "${configuredId}") from "${String(property.type)}" to "${type}", or restore a ${type} property and configure its ID.`
+      );
     }
-    if (!template)
-        throw new Error('The Feedbax project template is missing from this package.');
-    await cp(template, destination, { recursive: true });
-    await replaceInTree(destination, {
-        __GENERATOR_VERSION__: '0.1.0',
-        __IDENTITY__: options.identity,
-        __DEPLOYMENT__: options.deploy,
-        __PACKAGE_MANAGER__: options.packageManager,
-        __PACKAGE_MANAGER_SPEC__: options.packageManager === 'pnpm' ? 'pnpm@10.29.3' : 'npm@11.4.2',
-        __PRESET__: options.preset,
-        __NITRO_PRESET__: options.deploy === 'vercel'
-            ? 'vercel'
-            : options.deploy === 'cloudflare'
-                ? 'cloudflare-module'
-                : 'node-server',
+  }
+  if (repairs.length) throw new Error(repairs.join("\n"));
+  return {
+    databaseId: databaseIdFromResponse(dataSource),
+    dataSourceId,
+    propertyIds: { ...propertyIds }
+  };
+}
+function configurationFromResponse(dataSource, databaseId) {
+  const properties = recordAt(dataSource, "properties");
+  return {
+    databaseId,
+    dataSourceId: requiredString(dataSource.id),
+    propertyIds: Object.fromEntries(
+      Object.entries(canonicalProperties2).map(([key, { name }]) => [
+        key,
+        requiredString(recordAt(properties, name).id)
+      ])
+    )
+  };
+}
+function databaseIdFromResponse(dataSource) {
+  return requiredString(recordAt(dataSource, "parent").database_id);
+}
+function notionHeaders2(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Notion-Version": NOTION_API_VERSION2
+  };
+}
+async function readObject(response, subject) {
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      `Notion rejected the ${subject} request (${response.status}).`
+    );
+  }
+  if (!isRecord(body))
+    throw new Error(`Notion returned an invalid ${subject} response.`);
+  return body;
+}
+function recordAt(value, key) {
+  return record(value[key]);
+}
+function record(value) {
+  if (!isRecord(value))
+    throw new Error("Notion returned an invalid Changelog response.");
+  return value;
+}
+function requiredString(value) {
+  if (typeof value !== "string")
+    throw new Error("Notion returned an invalid Changelog response.");
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/index.ts
+function defaultProcessingQueueName(workerName) {
+  return workerName.length <= 55 ? `${workerName}-updates` : `${workerName.slice(0, 46)}-${createHash2("sha256").update(workerName).digest("hex").slice(0, 8)}-updates`;
+}
+async function provisionGuidedInstallation({
+  destination,
+  product,
+  themePreset,
+  workerName,
+  commentProbePageId,
+  connected,
+  features,
+  feedbackSelection,
+  changelogSelection,
+  notionToken,
+  turnstile,
+  preview,
+  request = fetch
+}) {
+  try {
+    if ((await readdir2(destination)).length)
+      throw new Error(
+        `Refusing to generate into non-empty destination: ${destination}`
+      );
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (product.siteUrl && new URL(product.siteUrl).protocol !== "https:")
+    throw new Error("product.siteUrl must be an HTTPS URL.");
+  if (connected) {
+    if (!product.siteUrl || connected.handoffSecret.length < 32 || !/^[0-9a-f-]{36}$/i.test(connected.databaseId) || !connected.databaseName.trim())
+      throw new Error(
+        "Connected setup requires a public site URL, dedicated D1 identifiers, and a handoff secret of at least 32 characters."
+      );
+    for (const url of [connected.issuer, connected.loginUrl])
+      if (new URL(url).protocol !== "https:" || new URL(url).username || new URL(url).password)
+        throw new Error(
+          "Connected identity URLs must use HTTPS without credentials."
+        );
+  }
+  if (connected?.email) {
+    const sender = connected.email;
+    if (!["cloudflare", "resend", "custom"].includes(sender.provider) || !/^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/.test(sender.from))
+      throw new Error(
+        "Choose cloudflare, resend, or custom and a plain sender email address."
+      );
+    if (sender.provider !== "cloudflare" && !sender.secret?.trim())
+      throw new Error(
+        "Resend and custom delivery require a server-only email secret."
+      );
+    if (sender.provider === "custom" && (!sender.endpoint || new URL(sender.endpoint).protocol !== "https:" || new URL(sender.endpoint).username || new URL(sender.endpoint).password || new URL(sender.endpoint).hash))
+      throw new Error(
+        "Custom delivery requires an HTTPS endpoint without credentials or fragments."
+      );
+  }
+  if (connected?.imageBucket && !/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/.test(connected.imageBucket))
+    throw new Error(
+      "Use a dedicated private R2 bucket name of 3\u201363 lowercase letters, digits, or hyphens."
+    );
+  const targetName = workerName ?? basename(destination).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(targetName))
+    throw new Error(
+      "Worker name must contain 1\u201363 lowercase letters, numbers, or hyphens."
+    );
+  const processingQueue = connected && connected.processing !== "standard" ? connected.queueName ?? defaultProcessingQueueName(targetName) : void 0;
+  if (processingQueue && !/^[a-z0-9][a-z0-9-]{0,62}$/.test(processingQueue))
+    throw new Error(
+      "Processing queue name must contain 1\u201363 lowercase letters, numbers, or hyphens."
+    );
+  const approved = await preview(
+    feedbackSelection.kind === "create" ? `Create the canonical Feedback Data Source inside Notion page ${feedbackSelection.parentPageId}.` : `Validate existing Feedback Data Source ${feedbackSelection.configuration.dataSourceId} without changing it.`
+  );
+  if (!approved)
+    throw new Error(
+      "Feedback setup was not approved. No local files were created."
+    );
+  const feedback = feedbackSelection.kind === "create" ? await createNotionFeedbackDataSource({
+    token: notionToken,
+    parentPageId: feedbackSelection.parentPageId,
+    request
+  }) : await validateNotionFeedbackDataSource({
+    token: notionToken,
+    ...feedbackSelection.configuration,
+    request
+  });
+  if (feedbackSelection.kind === "create") {
+    if (!await preview(
+      "Create six Notion team views: Inbox, Reviewing, Prioritization, Follow-up, Roadmap, and Shipped."
+    ))
+      throw new Error("Workflow view creation was not approved.");
+    await createFeedbackWorkflowViews({
+      token: notionToken,
+      ...feedback,
+      request
     });
-    try {
-        if (options.install) {
-            await run(options.packageManager, ['install'], destination);
-            await run(options.packageManager, ['run', 'type-check'], destination);
-        }
-        if (options.git)
-            await run('git', ['init'], destination);
-    }
-    catch (error) {
-        await writeFile(join(destination, '.feedbax-recovery'), `Generation stopped: ${error instanceof Error ? error.message : String(error)}\nRerun dependency installation and type checking after resolving the reported issue.\n`);
-        throw error;
-    }
-    return {
-        destination,
-        nextSteps: [
-            `cd ${options.directory}`,
-            'Copy .env.example to .env and configure Notion',
-            `${options.packageManager === 'pnpm' ? 'pnpm' : 'npx'} feedbax doctor`,
-            `${options.packageManager} run dev`,
-        ],
-    };
+  }
+  await verifySelectedCommentCapabilities(features, {
+    token: notionToken,
+    pageId: commentProbePageId ?? (feedbackSelection.kind === "create" ? feedbackSelection.parentPageId : feedback.databaseId),
+    request,
+    command: "setup"
+  });
+  const changelog = await configureChangelogStorage({
+    features,
+    selection: changelogSelection ?? (features.changelog ? { kind: "create", databaseId: feedback.databaseId } : void 0),
+    token: notionToken,
+    request,
+    preview
+  });
+  await copyPackagedTemplate(destination);
+  const wranglerPath = join2(destination, "wrangler.jsonc");
+  const wrangler = JSON.parse(await readFile2(wranglerPath, "utf8"));
+  await writeFile2(
+    wranglerPath,
+    JSON.stringify(
+      {
+        ...wrangler,
+        name: targetName,
+        ...connected ? {
+          triggers: { crons: ["*/5 * * * *"] },
+          ...processingQueue ? {
+            queues: {
+              producers: [
+                { binding: "FEEDBAX_UPDATES", queue: processingQueue }
+              ],
+              consumers: [
+                {
+                  queue: processingQueue,
+                  max_batch_size: 1,
+                  max_batch_timeout: 1,
+                  max_retries: 3,
+                  max_concurrency: 1,
+                  retry_delay: 60
+                }
+              ]
+            }
+          } : {},
+          ...connected.email?.provider === "cloudflare" ? {
+            send_email: [
+              {
+                name: "FEEDBAX_EMAIL",
+                allowed_sender_addresses: [connected.email.from]
+              }
+            ]
+          } : {},
+          ...connected.imageBucket ? {
+            r2_buckets: [
+              {
+                binding: "FEEDBAX_IMAGES",
+                bucket_name: connected.imageBucket
+              }
+            ]
+          } : {},
+          d1_databases: [
+            {
+              binding: "FEEDBAX_DB",
+              database_id: connected.databaseId,
+              database_name: connected.databaseName,
+              migrations_dir: "migrations"
+            }
+          ]
+        } : {}
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  const apiKey = randomBytes(32).toString("base64url");
+  const signingSecret = randomBytes(32).toString("base64url");
+  const values = {
+    NOTION_TOKEN: notionToken,
+    NOTION_FEEDBACK_DATABASE_ID: feedback.databaseId,
+    NOTION_FEEDBACK_DATA_SOURCE_ID: feedback.dataSourceId,
+    ...prefixProperties("NOTION_FEEDBACK", feedback.propertyIds),
+    FEEDBAX_API_KEY_HASH: createHash2("sha256").update(apiKey).digest("base64url"),
+    PARTICIPATION_SIGNING_SECRET: signingSecret,
+    ...connected ? { IDENTITY_HANDOFF_SECRET: connected.handoffSecret } : {},
+    ...connected?.email?.secret ? { EMAIL_PROVIDER_SECRET: connected.email.secret } : {},
+    FEEDBAX_VOTING_ENABLED: String(features.voting),
+    FEEDBAX_COMMENTS_ENABLED: String(features.comments),
+    FEEDBAX_CHANGELOG_ENABLED: String(features.changelog),
+    ...turnstile.siteKey ? { VITE_TURNSTILE_SITE_KEY: turnstile.siteKey } : {},
+    ...turnstile.secretKey ? { TURNSTILE_SECRET_KEY: turnstile.secretKey } : {},
+    ...changelog ? {
+      NOTION_CHANGELOG_DATABASE_ID: changelog.databaseId,
+      NOTION_CHANGELOG_DATA_SOURCE_ID: changelog.dataSourceId,
+      ...prefixProperties("NOTION_CHANGELOG", changelog.propertyIds)
+    } : {}
+  };
+  await writeFile2(
+    join2(destination, ".dev.vars"),
+    Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n") + "\n",
+    { mode: 384 }
+  );
+  const configuration = defineFeedbax({
+    product: { ...product, logo: "/feedbax-mark.svg" },
+    theme: { preset: themePreset },
+    ...connected ? {
+      connected: {
+        processing: connected.processing ?? "small",
+        issuer: connected.issuer,
+        loginUrl: connected.loginUrl,
+        ...connected.email ? {
+          email: {
+            provider: connected.email.provider,
+            from: connected.email.from,
+            ...connected.email.endpoint ? { endpoint: connected.email.endpoint } : {}
+          }
+        } : {},
+        ...connected.imageBucket ? { images: true } : {}
+      }
+    } : {},
+    notion: {
+      databaseId: feedback.databaseId,
+      dataSourceId: feedback.dataSourceId,
+      properties: feedback.propertyIds
+    },
+    ...changelog ? {
+      changelog: {
+        databaseId: changelog.databaseId,
+        dataSourceId: changelog.dataSourceId,
+        properties: changelog.propertyIds
+      }
+    } : {},
+    features,
+    submissions: {
+      moderation: "required",
+      maxTitleLength: 160,
+      maxDescriptionLength: 5e3
+    },
+    turnstile: {
+      enabled: Boolean(turnstile.siteKey),
+      ...turnstile.siteKey ? { siteKey: turnstile.siteKey } : {}
+    }
+  });
+  await writeFile2(
+    join2(destination, "src/feedbax.ts"),
+    `import { defineFeedbax } from "@feedbax/config";
+
+export default defineFeedbax(${JSON.stringify(configuration, null, 2)});
+`
+  );
+  const probePage = commentProbePageId ?? (feedbackSelection.kind === "create" ? feedbackSelection.parentPageId : feedback.databaseId);
+  await writeFile2(
+    join2(destination, ".dev.vars"),
+    `NOTION_COMMENT_CAPABILITY_PROBE_PAGE_ID=${JSON.stringify(probePage)}
+`,
+    { flag: "a", mode: 384 }
+  );
+  return { apiKey, feedback, changelog, processingQueue };
 }
-//# sourceMappingURL=index.js.map
+function prefixProperties(prefix, properties) {
+  return Object.fromEntries(
+    Object.entries(properties).map(([key, value]) => [
+      `${prefix}_${key.replace(/[A-Z]/g, (letter) => `_${letter}`).toUpperCase()}_PROPERTY_ID`,
+      value
+    ])
+  );
+}
+var featureChoices = [
+  { key: "voting", label: "Voting", initialValue: true },
+  { key: "comments", label: "Comments", initialValue: true },
+  { key: "changelog", label: "Changelog", initialValue: true }
+];
+async function collectFeatureSelection(prompter) {
+  const selections = [];
+  for (const { key, label, initialValue } of featureChoices) {
+    selections.push([
+      key,
+      await prompter.confirm({
+        message: `Enable ${label}?`,
+        initialValue
+      })
+    ]);
+  }
+  return Object.fromEntries(selections);
+}
+function renderFeatureConfiguration(features) {
+  return `features: {
+    voting: ${features.voting},
+    comments: ${features.comments},
+    changelog: ${features.changelog},
+  },`;
+}
+function renderChangelogConfiguration(configuration) {
+  const properties = Object.entries(configuration.propertyIds).map(([key, value]) => `      ${key}: ${JSON.stringify(value)},`).join("\n");
+  return `changelog: {
+    databaseId: ${JSON.stringify(configuration.databaseId)},
+    dataSourceId: ${JSON.stringify(configuration.dataSourceId)},
+    propertyIds: {
+${properties}
+    },
+  },`;
+}
+async function verifySelectedCommentCapabilities(features, {
+  token,
+  pageId,
+  request = fetch,
+  command = "setup"
+}) {
+  if (!features.comments) return;
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Notion-Version": "2026-03-11"
+  };
+  const readResponse = await request(
+    `https://api.notion.com/v1/comments?block_id=${encodeURIComponent(pageId)}&page_size=1`,
+    { headers }
+  );
+  if (!readResponse.ok) {
+    if (readResponse.status === 403)
+      assertEnabledCommentCapabilities({
+        commentsEnabled: true,
+        capabilities: { readComments: false, insertComments: true },
+        command
+      });
+    throw new Error(
+      `Notion Comment read check failed (HTTP ${readResponse.status}). Verify a shared page ID and connection access.`
+    );
+  }
+  if (command === "doctor") {
+    assertEnabledCommentCapabilities({
+      commentsEnabled: true,
+      capabilities: {
+        readComments: readResponse.status !== 403,
+        // Setup proves Insert comments before enabling the capability. Doctor
+        // deliberately avoids a write-method probe and verifies the live read path.
+        insertComments: true
+      },
+      command
+    });
+    return;
+  }
+  const insertResponse = await request("https://api.notion.com/v1/comments", {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: "{}"
+  });
+  if (insertResponse.status !== 400 && insertResponse.status !== 403)
+    throw new Error(
+      `Notion Comment insert capability check failed (HTTP ${insertResponse.status}).`
+    );
+  const capabilities = {
+    readComments: readResponse.status !== 403,
+    insertComments: insertResponse.status !== 403
+  };
+  assertEnabledCommentCapabilities({
+    commentsEnabled: true,
+    capabilities,
+    command
+  });
+}
+function assertEnabledCommentCapabilities({
+  commentsEnabled,
+  capabilities,
+  command = "setup"
+}) {
+  if (!commentsEnabled) return;
+  const missing = [
+    ...capabilities.readComments ? [] : ["Read comments"],
+    ...capabilities.insertComments ? [] : ["Insert comments"]
+  ];
+  if (missing.length === 0) return;
+  const retry = command === "doctor" ? "rerun doctor. No changes were made." : "retry setup.";
+  throw new Error(
+    `Enable ${missing.join(" and ")} in the Notion connection settings, then ${retry}`
+  );
+}
+async function configureChangelogStorage({
+  features,
+  selection,
+  token,
+  request = fetch,
+  preview
+}) {
+  if (!features.changelog) return;
+  if (!selection) {
+    throw new Error(
+      "Choose an existing compatible Changelog Data Source or create one beside Feedback."
+    );
+  }
+  if (selection.kind === "existing") {
+    return validateNotionChangelogDataSource({
+      token,
+      dataSourceId: selection.dataSourceId,
+      propertyIds: selection.propertyIds,
+      request
+    });
+  }
+  const approved = await preview(
+    `Create an empty Changelog Data Source beside Feedback in Feedbax Database ${selection.databaseId}. No sample entries will be published.`
+  );
+  if (!approved) throw new Error("Changelog creation was not approved.");
+  return createNotionChangelogDataSource({
+    token,
+    databaseId: selection.databaseId,
+    request
+  });
+}
+async function doctorChangelogStorage({
+  enabled,
+  configuration,
+  token,
+  request = fetch
+}) {
+  if (!enabled) return;
+  if (!configuration) {
+    throw new Error(
+      "Changelog is enabled without identifiers and property mappings. Create or select a compatible Changelog Data Source, configure it, then rerun doctor. No changes were made."
+    );
+  }
+  await validateNotionChangelogDataSource({
+    token,
+    dataSourceId: configuration.dataSourceId,
+    propertyIds: configuration.propertyIds,
+    request
+  });
+}
+async function doctorInstallation({
+  features,
+  feedback,
+  changelog,
+  commentProbePageId,
+  token,
+  request = fetch
+}) {
+  await validateNotionFeedbackDataSource({ token, ...feedback, request });
+  if (features.comments) {
+    if (!commentProbePageId) {
+      throw new Error(
+        "Comments are enabled but no Comment capability probe page is configured. Configure one, then rerun doctor. No changes were made."
+      );
+    }
+    await verifySelectedCommentCapabilities(features, {
+      token,
+      pageId: commentProbePageId,
+      request,
+      command: "doctor"
+    });
+  }
+  await doctorChangelogStorage({
+    enabled: features.changelog,
+    configuration: changelog,
+    token,
+    request
+  });
+}
+export {
+  assembleFlatTemplate,
+  assertEnabledCommentCapabilities,
+  collectFeatureSelection,
+  configureChangelogStorage,
+  copyPackagedTemplate,
+  defaultProcessingQueueName,
+  doctorChangelogStorage,
+  doctorInstallation,
+  featureChoices,
+  provisionGuidedInstallation,
+  renderChangelogConfiguration,
+  renderFeatureConfiguration,
+  templateChecksum,
+  verifyPackagedTemplate,
+  verifySelectedCommentCapabilities
+};