create-feedbax 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,173 +1,1415 @@
-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.`);
+// 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 = [
+  "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")
+  };
+  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,
+    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, "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")
+  );
+  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/components/ui/styles/globals.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, version]) => [
+      name,
+      version === "catalog:" ? catalog[name] : version
+    ])
+  );
+  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",
+      "@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"]
+    }
+  }
 };
-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;
-        }
-        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;
+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" }
+        ]
+      }
     }
-    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'),
-    };
-}
-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);
-    };
-    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}`);
+  },
+  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" }]
+      }
     }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
+  },
+  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 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);
+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);
+  }
 }
-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'),
-    ];
-    let template;
-    for (const candidate of candidates) {
-        try {
-            if ((await stat(candidate)).isDirectory()) {
-                template = candidate;
-                break;
-            }
-        }
-        catch {
-            continue;
+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.`
+          );
         }
+        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);
+}
+
+// ../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
+async function provisionGuidedInstallation({
+  destination,
+  product,
+  themePreset,
+  workerName,
+  commentProbePageId,
+  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.");
+  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 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);
+  }
+  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 }, 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,
+    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 },
+    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 } : {}
     }
-    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;
+  });
+  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 };
+}
+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."
+      );
     }
-    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`,
-        ],
-    };
-}
-//# sourceMappingURL=index.js.map
+    await verifySelectedCommentCapabilities(features, {
+      token,
+      pageId: commentProbePageId,
+      request,
+      command: "doctor"
+    });
+  }
+  await doctorChangelogStorage({
+    enabled: features.changelog,
+    configuration: changelog,
+    token,
+    request
+  });
+}
+export {
+  assembleFlatTemplate,
+  assertEnabledCommentCapabilities,
+  collectFeatureSelection,
+  configureChangelogStorage,
+  copyPackagedTemplate,
+  doctorChangelogStorage,
+  doctorInstallation,
+  featureChoices,
+  provisionGuidedInstallation,
+  renderChangelogConfiguration,
+  renderFeatureConfiguration,
+  templateChecksum,
+  verifyPackagedTemplate,
+  verifySelectedCommentCapabilities
+};