@stacksjs/actions 0.70.88 → 0.70.91

package/dist/dev/views.js

@@ -0,0 +1,147 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync } from "node:fs";
+import { config, overridesReady } from "@stacksjs/config";
+import { projectPath } from "@stacksjs/path";
+const requestStore = new AsyncLocalStorage;
+function currentRequestContext() {
+  return requestStore.getStore() ?? globalThis.__stxServeContext;
+}
+globalThis.requestContext = {
+  cookie(name) {
+    return currentRequestContext()?.cookies?.[name] ?? null;
+  },
+  url() {
+    return currentRequestContext()?.url ?? "";
+  },
+  locale() {
+    return currentRequestContext()?.locale ?? "de";
+  }
+};
+const projectServe = projectPath("serve.ts");
+try {
+  if (await Bun.file(projectServe).exists())
+    await import(projectServe);
+  else
+    await startDefaultServer();
+} catch {
+  await startDefaultServer();
+}
+function parseCookies(req) {
+  const out = {}, header = req.headers.get("cookie") || "";
+  if (!header)
+    return out;
+  for (const part of header.split(";")) {
+    const trimmed = part.trim(), eq = trimmed.indexOf("=");
+    if (eq === -1)
+      continue;
+    const k = trimmed.slice(0, eq).trim(), v = trimmed.slice(eq + 1).trim();
+    if (!k)
+      continue;
+    try {
+      out[k] = decodeURIComponent(v);
+    } catch {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+async function startDefaultServer() {
+  await overridesReady;
+  const { injectGlobalAutoImports, isApiBoundRequest, proxyToBackend } = await import("@stacksjs/server"), { applyRequestLocale } = await import("@stacksjs/i18n");
+  await injectGlobalAutoImports();
+  const { serve } = await import("bun-plugin-stx/serve"), { site: siteConfig, i18n: i18nConfig } = await loadStxSiteConfig(), userViewsPath = "resources/views", defaultViewsPath = "storage/framework/defaults/resources/views", userLayoutsPath = await firstExistingPath([
+    "resources/views/layouts",
+    "resources/layouts"
+  ]) ?? "resources/views/layouts", defaultLayoutsPath = "storage/framework/defaults/resources/layouts", userComponentsPath = await firstExistingPath([
+    "resources/views/components",
+    "resources/components"
+  ]) ?? "resources/views/components", preferredPort = Number(process.env.PORT) || 3000, apiPort = Number(process.env.PORT_API) || 3008, docsPort = Number(process.env.PORT_DOCS) || config.ports?.docs || 3006, apiBase = `http://127.0.0.1:${apiPort}`, docsBase = `http://127.0.0.1:${docsPort}`, authCookie = config?.auth?.defaultTokenName ?? "auth-token";
+  await serve({
+    patterns: [userViewsPath, defaultViewsPath],
+    port: preferredPort,
+    componentsDir: "storage/framework/defaults/resources/components",
+    layoutsDir: userLayoutsPath,
+    partialsDir: userComponentsPath,
+    fallbackLayoutsDir: defaultLayoutsPath,
+    fallbackPartialsDir: defaultViewsPath,
+    quiet: !0,
+    ...i18nConfig && { i18n: i18nConfig },
+    ...siteConfig?.url && { site: siteConfig },
+    auth: {
+      cookieName: authCookie,
+      redirectTo: "/login"
+    },
+    onRequest: async (req) => {
+      const url = new URL(req.url), { maintenanceGate } = await import("@stacksjs/server"), gated = await maintenanceGate(req);
+      if (gated)
+        return gated;
+      if (existsSync(projectPath("resources/views/blog.stx"))) {
+        const { renderBlogFeed } = await import("../blog"), feed = await renderBlogFeed(req);
+        if (feed)
+          return feed;
+      } else {
+        const { renderBlog } = await import("../blog"), blogResponse = await renderBlog(req);
+        if (blogResponse)
+          return blogResponse;
+      }
+      if (url.pathname === "/docs" || url.pathname.startsWith("/docs/"))
+        return proxyToBackend(req, docsBase, "/docs");
+      if (isApiBoundRequest(req, url.pathname))
+        return proxyToBackend(req, apiBase);
+      if (i18nConfig && req.method === "GET") {
+        const localeSwitch = url.pathname.match(/^\/locale\/([a-z]{2}(?:-[a-z]{2})?)\/?$/i);
+        if (localeSwitch) {
+          const { createLocaleSwitchResponse } = await import("@stacksjs/i18n");
+          return createLocaleSwitchResponse(req, localeSwitch[1], i18nConfig);
+        }
+      }
+      const locale = await applyRequestLocale(req), ctx = { cookies: parseCookies(req), url: req.url, locale };
+      globalThis.__stxServeSearch = url.search;
+      globalThis.__stxServeContext = ctx;
+      requestStore.enterWith(ctx);
+      return null;
+    }
+  });
+}
+async function firstExistingPath(candidates) {
+  for (const candidate of candidates)
+    if (existsSync(projectPath(candidate)))
+      return candidate;
+  return null;
+}
+function fallbackI18nFromSite(site) {
+  const locales = site.i18n.locales, defaultLocale = site.i18n.defaultLocale ?? locales[0];
+  return {
+    locales,
+    defaultLocale,
+    labels: site.i18n.labels ?? Object.fromEntries(locales.map((c) => [c, c.toUpperCase()])),
+    translations: {},
+    pickerSelector: site.i18n.pickerSelector ?? "#lang-picker"
+  };
+}
+async function resolveSiteI18n(site) {
+  try {
+    const { resolveI18n } = await import("@stacksjs/stx");
+    if (typeof resolveI18n === "function") {
+      const i18n = resolveI18n(site, projectPath());
+      if (i18n)
+        return i18n;
+    }
+  } catch {}
+  return fallbackI18nFromSite(site);
+}
+async function loadStxSiteConfig() {
+  const sitePath = projectPath("site.config.ts");
+  if (!existsSync(sitePath))
+    return {};
+  try {
+    const site = (await import(sitePath)).default;
+    if (!site)
+      return {};
+    if (!site.i18n)
+      return { site };
+    const i18n = await resolveSiteI18n(site);
+    return { site, i18n };
+  } catch {}
+  return {};
+}

package/dist/discover-packages.d.ts

@@ -0,0 +1,18 @@
+import type { StackDirectory } from '@stacksjs/types';
+export declare function discoverPackages(): Promise<DiscoveredPackagesManifest>;
+export declare interface PackageStacksMeta {
+  providers?: string[]
+  routes?: string[]
+  views?: string[]
+  components?: string[]
+  commands?: string[]
+  middleware?: string[]
+  migrations?: string[]
+  name?: string
+  description?: string
+  directories?: StackDirectory[]
+}
+export declare interface DiscoveredPackagesManifest {
+  generated_at: string
+  packages: Record<string, PackageStacksMeta>
+}

package/dist/discover-packages.js

@@ -0,0 +1,32 @@
+import { projectPath, storagePath } from "@stacksjs/path";
+export async function discoverPackages() {
+  const manifest = {
+    generated_at: new Date().toISOString(),
+    packages: {}
+  }, dontDiscover = new Set;
+  try {
+    const list = (await Bun.file(projectPath("package.json")).json())?.stacks?.["dont-discover"];
+    if (Array.isArray(list))
+      for (const name of list)
+        dontDiscover.add(name);
+  } catch {}
+  const pantryDir = projectPath("pantry"), patterns = ["*/package.json", "@*/*/package.json"];
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan({ cwd: pantryDir, absolute: !0, onlyFiles: !0 }))
+      try {
+        const pkg = await Bun.file(file).json(), name = pkg?.name;
+        if (!name || !pkg.stacks || dontDiscover.has(name))
+          continue;
+        manifest.packages[name] = pkg.stacks;
+      } catch {}
+  }
+  const manifestPath = storagePath("framework/discovered-packages.json");
+  try {
+    const current = await Bun.file(manifestPath).json();
+    if (JSON.stringify(current.packages ?? {}) === JSON.stringify(manifest.packages))
+      return current;
+  } catch {}
+  await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+  return manifest;
+}

package/dist/domains/add.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domains/add.js

@@ -0,0 +1,61 @@
+import process from "node:process";
+import { italic, log, parseOptions, runCommand } from "@stacksjs/cli";
+import { createHostedZone, getHostedZoneNameservers, updateNameservers } from "@stacksjs/dns";
+import { loadEnv } from "@stacksjs/env";
+import { handleError } from "@stacksjs/error-handling";
+import { projectConfigPath } from "@stacksjs/path";
+import { whois } from "@stacksjs/whois";
+loadEnv({
+  path: [".env", ".env.production"],
+  overload: !0
+});
+const options = parseOptions();
+function normalizeDomain(url) {
+  if (!url)
+    return;
+  return url.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+const domain = normalizeDomain(options.domain ?? process.env.APP_URL);
+if (!domain) {
+  log.error("There was no Domain or App URL provided. Please provide a domain using the --domain flag or add a url to your app config.");
+  process.exit(1);
+}
+const result = await createHostedZone(domain);
+if (result.isErr) {
+  handleError(result.error);
+  process.exit(1);
+}
+const nameServers = await getHostedZoneNameservers(domain);
+if (!nameServers || nameServers.length === 0) {
+  handleError(`No nameservers found for domain: ${domain}. Please ensure the Hosted Zone exists in Route53.`);
+  process.exit(1);
+}
+await updateNameservers(nameServers);
+const registrar = (await whois(domain, !0)).parsedData.Registrar;
+if (registrar.includes("Amazon")) {
+  if (options.deploy)
+    await runCommand("buddy deploy");
+  else {
+    log.info("");
+    log.info("You can now continue your deployment process by re-running:");
+    log.info("");
+    log.info(`  \u27A1\uFE0F  ${italic("buddy deploy")}`);
+    log.info("");
+  }
+  process.exit(0);
+}
+log.info("");
+log.info("\u2139\uFE0F  Please note, before continuing your deployment process,");
+log.info(`   update your ${registrar} nameservers to the following:`);
+const emojis = ["1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3", "4\uFE0F\u20E3"];
+log.info("");
+nameServers.forEach((nameserver, index) => {
+  log.info(`  ${emojis[index]}  Nameserver: ${nameserver}`);
+});
+log.info("");
+log.info(italic(`stored in ${projectConfigPath("dns.ts")}`));
+log.info("");
+log.info("Once the nameservers have been updated, re-run the following command:");
+log.info("");
+log.info(`  \u27A1\uFE0F  ${italic("buddy deploy")}`);
+log.info("");

package/dist/domains/purchase.d.ts

@@ -0,0 +1 @@
+declare type CountryCode = string;

package/dist/domains/purchase.js

@@ -0,0 +1,66 @@
+import process from "node:process";
+import { log, parseOptions } from "@stacksjs/cli";
+import { purchaseDomain } from "@stacksjs/cloud";
+import { config } from "@stacksjs/config";
+import { handleError } from "@stacksjs/error-handling";
+import { ExitCode } from "@stacksjs/types";
+const c = config.dns.contactInfo;
+if (!c) {
+  handleError("You must provide contact info in your config file.");
+  process.exit(ExitCode.FatalError);
+}
+const defaultOptions = {
+  domain: "",
+  years: 1,
+  privacy: !0,
+  autoRenew: !0,
+  registrantFirstName: c.firstName,
+  registrantLastName: c.lastName,
+  registrantOrganization: c.organizationName,
+  registrantAddressLine1: c.addressLine1,
+  registrantAddressLine2: c.addressLine2,
+  registrantCity: c.city,
+  registrantState: c.state,
+  registrantCountry: c.countryCode,
+  registrantZip: c.zip,
+  registrantPhone: c.phoneNumber,
+  registrantEmail: c.email,
+  adminFirstName: c.admin?.firstName || c.firstName,
+  adminLastName: c.admin?.lastName || c.lastName,
+  adminOrganization: c.admin?.organizationName || c.organizationName,
+  adminAddressLine1: c.admin?.addressLine1 || c.addressLine1,
+  adminAddressLine2: c.admin?.addressLine2 || c.addressLine2,
+  adminCity: c.admin?.city || c.city,
+  adminState: c.admin?.state || c.state,
+  adminCountry: c.admin?.countryCode || c.countryCode,
+  adminZip: c.admin?.zip || c.zip,
+  adminPhone: c.admin?.phoneNumber || c.phoneNumber,
+  adminEmail: c.admin?.email || c.email,
+  techFirstName: c.tech?.firstName || c.firstName,
+  techLastName: c.tech?.lastName || c.lastName,
+  techOrganization: c.tech?.organizationName || c.organizationName,
+  techAddressLine1: c.tech?.addressLine1 || c.addressLine1,
+  techAddressLine2: c.tech?.addressLine2 || c.addressLine2,
+  techCity: c.tech?.city || c.city,
+  techState: c.tech?.state || c.state,
+  techCountry: c.tech?.countryCode || c.countryCode,
+  techZip: c.tech?.zip || c.zip,
+  techPhone: c.tech?.phoneNumber || c.phoneNumber,
+  techEmail: c.tech?.email || c.email,
+  privacyAdmin: c.privacyAdmin || c.privacy || !0,
+  privacyTech: c.privacyTech || c.privacy || !0,
+  privacyRegistrant: c.privacyRegistrant || c.privacy || !0,
+  contactType: "PERSON",
+  verbose: !1
+}, options = { ...defaultOptions, ...parseOptions() };
+if (!options.domain) {
+  handleError("You must provide a domain name to purchase.");
+  process.exit(ExitCode.FatalError);
+}
+const result = purchaseDomain(options.domain, options);
+if (result.isErr) {
+  handleError(result.error);
+  process.exit(ExitCode.FatalError);
+}
+log.info("Domain purchased successfully.");
+process.exit(ExitCode.Success);

package/dist/domains/remove.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domains/remove.js

@@ -0,0 +1,24 @@
+import process from "node:process";
+import { parseOptions } from "@stacksjs/cli";
+import { app } from "@stacksjs/config";
+import { deleteHostedZoneRecords } from "@stacksjs/dns";
+import { handleError } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+const parsedOptions = parseOptions(), options = {
+  domain: parsedOptions.domain,
+  verbose: parsedOptions.verbose
+};
+if (!options.domain)
+  if (app.url)
+    options.domain = app.url;
+  else {
+    handleError("there was no domain provided when");
+    process.exit(1);
+  }
+if (options.verbose)
+  log.info(`Removing domain: ${options.domain}`);
+const result = await deleteHostedZoneRecords(options.domain);
+if (result.isErr) {
+  handleError(result.error);
+  process.exit(1);
+}

package/dist/examples.d.ts

@@ -0,0 +1,5 @@
+import type { ExamplesOptions } from '@stacksjs/types';
+export declare function invoke(options: ExamplesOptions): Promise<void>;
+export declare function examples(options: ExamplesOptions): Promise<void>;
+export declare function componentExample(options: ExamplesOptions): Promise<void>;
+export declare function webComponentExample(options: ExamplesOptions): Promise<void>;

package/dist/examples.js

@@ -0,0 +1,34 @@
+import process from "node:process";
+import { NpmScript } from "@stacksjs/enums";
+import { log } from "@stacksjs/logging";
+import { hasComponents } from "@stacksjs/storage";
+import { ExitCode } from "@stacksjs/types";
+import { runNpmScript } from "@stacksjs/utils";
+export async function invoke(options) {
+  if (options.components || options.vue)
+    await componentExample(options);
+  else if (options.webComponents || options.elements)
+    await webComponentExample(options);
+  else
+    log.error("An unsupported option was used. Please try again, check the documentation & report the issue, if needed.");
+}
+export async function examples(options) {
+  return await invoke(options);
+}
+export async function componentExample(options) {
+  if (hasComponents()) {
+    await runNpmScript(NpmScript.ExampleVue, options);
+    log.success("Your component library was built successfully");
+  } else
+    log.info("No components found.");
+}
+export async function webComponentExample(options) {
+  if (hasComponents()) {
+    log.info("Building your Web Component library...");
+    await runNpmScript(NpmScript.BuildWebComponents, options);
+    log.success("Your Web Component library was built successfully");
+  } else {
+    log.info("No components found.");
+    process.exit(ExitCode.FatalError);
+  }
+}

package/dist/find-projects.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/find-projects.js

@@ -0,0 +1,16 @@
+import process from "node:process";
+import { parseOptions } from "@stacksjs/cli";
+import { log } from "@stacksjs/logging";
+import { ExitCode } from "@stacksjs/types";
+import { findStacksProjects } from "@stacksjs/utils";
+try {
+  const options = parseOptions(), projects = await findStacksProjects(void 0, options);
+  if (projects.length > 0) {
+    log.info("Found Projects:");
+    projects.forEach((project) => console.log(`   - ${project}`));
+    process.exit(ExitCode.Success);
+  }
+  log.info("No Stacks Projects found.");
+} catch (error) {
+  log.error("Error searching for Stacks projects:", error);
+}

package/dist/fresh.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fresh.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+import { runCommand } from "@stacksjs/cli";
+import { handleError } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import { projectPath } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+import { cleanProject } from "@stacksjs/utils";
+log.info("Cleaning project...");
+await cleanProject();
+log.info("Installing dependencies...");
+const result = await runCommand("bun install", {
+  cwd: projectPath()
+});
+if (result.isErr) {
+  handleError(result.error);
+  process.exit(ExitCode.FatalError);
+}

package/dist/generate/action-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/action-types.js

@@ -0,0 +1,13 @@
+import { readdir } from "node:fs/promises";
+import { log } from "@stacksjs/logging";
+import { path as p } from "@stacksjs/path";
+import { storage } from "@stacksjs/storage";
+log.info("Generating action types...");
+const domain = "Actions", files = await readdir(p.appPath(domain), { recursive: !0 }), validActions = `// This file is auto-generated by Stacks. Do not edit this file manually.
+// If you wish to rename an action, please do so by editing the file name.
+//
+// For more information, please visit: https://stacksjs.com/docs
+
+export type ActionPath = ${files.filter((file) => file.endsWith(".ts")).map((value) => `'${domain}/${value.replace(".ts", "")}'`).join(" | ")}
+`;
+await storage.writeFile(p.frameworkPath("types/actions.d.ts"), validActions);

package/dist/generate/component-meta.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/component-meta.js

@@ -0,0 +1,9 @@
+import { log } from "@stacksjs/logging";
+import { hasComponents } from "@stacksjs/storage";
+import { generateComponentMeta } from "../helpers/component-meta";
+log.info("Generating component meta...");
+if (hasComponents())
+  generateComponentMeta();
+else
+  log.info("No components found. Skipping component meta generation.");
+log.success("Generated component meta.");

package/dist/generate/custom-cli-file.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/custom-cli-file.js

@@ -0,0 +1,21 @@
+import process from "node:process";
+import { cli } from "@stacksjs/config";
+import { log } from "@stacksjs/logging";
+import { projectPath } from "@stacksjs/path";
+import { writeTextFile } from "@stacksjs/storage";
+import { ExitCode } from "@stacksjs/types";
+log.info("Ensuring Component Library Entry Point...");
+if (!cli.command) {
+  log.error("No command defined in the CLI configuration");
+  process.exit(ExitCode.FatalError);
+}
+await writeTextFile({
+  path: projectPath(cli.command),
+  data: `#!/usr/bin/env bun
+import('./storage/framework/core/buddy/src/custom-cli')
+`
+}).catch((err) => {
+  log.error("There was an error generating your custom CLI file.", err);
+  process.exit(ExitCode.FatalError);
+});
+log.success("Generated custom CLI file");

package/dist/generate/env-files.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/env-files.js

@@ -0,0 +1,66 @@
+import { env as e, envEnum } from "@stacksjs/env";
+import { log } from "@stacksjs/logging";
+import { path as p } from "@stacksjs/path";
+import { storage } from "@stacksjs/storage";
+import { envKeys } from "../../../../env";
+log.info("Generating type env files...");
+const envTypes = `
+// This file is auto-generated by Stacks. Do not edit this file manually.
+// If you want to change the environment variables, please edit the .env file.
+//
+// For more information, please visit: https://stacksjs.com/docs
+
+declare module 'bun' {
+  namespace env {
+    ${envKeys.map((key) => {
+  let type = typeof e[key], value = e[key];
+  if (!value)
+    if (envEnum[key]) {
+      type = envEnum[key]?.map((item) => `'${item}'`).join(" | ");
+      value = envEnum[key]?.[0];
+    } else
+      switch (type) {
+        case "number":
+          value = "0";
+          break;
+        case "boolean":
+          value = !1;
+          break;
+        default:
+          value = "";
+      }
+  type = "string";
+  if (typeof value === "string") {
+    if (value.toLowerCase() === "true" || value.toLowerCase() === "false")
+      type = "boolean";
+    else if (!Number.isNaN(Number.parseFloat(value)) && Number.isFinite(Number(value)))
+      type = "number";
+    else if (envEnum[key])
+      type = envEnum[key].map((item) => `'${item}'`).join(" | ");
+  } else if (typeof value === "number")
+    type = "number";
+  else if (typeof value === "boolean")
+    type = "boolean";
+  return `const ${key}: ${type}`;
+}).join(`
+    `)}
+  }
+}
+`;
+await storage.writeFile(p.frameworkPath("types/env.d.ts"), envTypes);
+log.info("  - ./storage/framework/env.ts");
+const env = `
+// This file is auto-generated by Stacks. Do not edit this file manually.
+// If you want to change the environment variables, please edit the .env file.
+//
+// For more information, please visit: https://stacksjs.com/docs
+
+export const envKeys = [
+  ${envKeys.map((key) => `'${key}'`).join(`,
+  `)}
+] as const
+
+export type EnvKey = typeof envKeys[number]
+`;
+await storage.writeFile(p.frameworkPath("env.ts"), env);
+log.info("  - ./storage/framework/env.d.ts");

package/dist/generate/ide-helpers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generate/ide-helpers.js

@@ -0,0 +1,8 @@
+import { log } from "@stacksjs/logging";
+import { hasComponents } from "@stacksjs/storage";
+import { generateVsCodeCustomData, generateWebTypes } from "../helpers/vscode-custom-data";
+if (hasComponents()) {
+  await generateWebTypes();
+  await generateVsCodeCustomData();
+} else
+  log.info("No components found. Skipping IDE helper generation.");

package/dist/generate/index.d.ts

@@ -0,0 +1,36 @@
+import type { GeneratorOptions } from '@stacksjs/types';
+// import { files } from '@stacksjs/storage'
+export declare function invoke(options?: GeneratorOptions): Promise<void>;
+export declare function generate(options: GeneratorOptions): Promise<void>;
+export declare function generateLibEntries(options: GeneratorOptions): Promise<void>;
+export declare function generateWebTypes(options?: GeneratorOptions): Promise<void>;
+export declare function generateVsCodeCustomData(): Promise<void>;
+export declare function generateIdeHelpers(options?: GeneratorOptions): Promise<void>;
+export declare function generateComponentMeta(): Promise<void>;
+export declare function generateTypes(options?: GeneratorOptions): Promise<void>;
+/**
+ * Watch model + config + migration source for changes and re-run
+ * `generateTypes()` whenever any of them change. Debounced at 200ms so
+ * a refactor that touches a dozen files in one save coalesces into a
+ * single regen pass.
+ *
+ * Watched roots:
+ *   - `app/Models/`                                 — userland models
+ *   - `storage/framework/defaults/app/Models/`      — framework defaults
+ *     (Stacks' equivalent of Laravel's vendor/. When you're working on
+ *     the framework itself you edit here and need fresh types just as
+ *     much as a userland edit.)
+ *   - `config/`
+ *   - `database/migrations/`
+ *
+ * `inflight` guards against re-entry: a slow regen shouldn't queue up
+ * three more behind it. `pending` debounces a burst of saves into one
+ * fire. The returned promise only resolves on SIGINT, so the caller
+ * either awaits (blocking, like `generate:types --watch`) or fires it
+ * non-blocking (sidecar use, like `dev:api`).
+ */
+export declare function watchTypes(options?: GeneratorOptions): Promise<void>;
+export declare function generatePantryConfig(): void;
+export declare function generateSeeder(): Promise<void>;
+export declare function generateCoreSymlink(): Promise<void>;
+export declare function generateOpenApiSpec(): Promise<void>;