@deltabox/toolchain 0.0.0-stage → 1.1.21

package/dist/packages/changelog/src/utils/summary.d.ts

@@ -0,0 +1,7 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { CommitRecord } from "./types.js";
+//#region packages/changelog/src/utils/summary.d.ts
+/** Render the grouped changelog summary for a set of commits. */
+export declare function buildSummary(records: CommitRecord[]): string;
+//#endregion

package/dist/packages/changelog/src/utils/summary.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{recordIssues as e,renderAuthor as t,renderIssues as n,repoSlug as r,resolveAuthorInfo as i}from"./git.js";import{capitalize as a,formatBody as o,groupItems as s,parseCcSubject as c,renderGroups as l}from"./format.js";function u(u){let d=r(),f=s(u.map(r=>{let s=c(r.subject),l=r.hash.slice(0,7),u=t(i(r,d));return{parsed:s,text:`- ${a(s.rest)} ([#${l}](https://github.com/${d}/commit/${r.hash}) by ${u})${n(e(r,d))}`,bodyParagraphs:o(r.body)}}));return l(f)}export{u as buildSummary};

package/dist/packages/changelog/src/utils/types.d.ts

@@ -0,0 +1,58 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/changelog/src/utils/types.d.ts
+/** Shared types for the changelog pipeline. */
+export type BumpType = 'major' | 'minor' | 'patch';
+export type ProcessingMethod = 'latest' | 'all' | string;
+export interface CommitRecord {
+  hash: string;
+  subject: string;
+  body: string;
+  author: string;
+  authorEmail: string;
+}
+export interface AuthorInfo {
+  name: string;
+  url?: string;
+}
+export interface IssueInfo {
+  number: number;
+  title?: string;
+  url?: string;
+}
+export interface CliOptions {
+  range: string;
+  dryRun: boolean;
+  version?: string;
+  baseVersion?: string;
+  processingMethod: ProcessingMethod;
+  formatOnly: boolean;
+  /** Include the `### Package changes` footer (disable with --no-package-changes-section). */
+  packageChanges: boolean;
+}
+/** A Conventional-Commits subject parsed into its parts. */
+export interface ParsedCommit {
+  type: string;
+  scope?: string;
+  breaking: boolean;
+  /** Everything after the `type(scope):` prefix (subject + link/author suffix). */
+  rest: string;
+}
+/** A list of parsed commits grouped by CC rule, then by scope. */
+export interface GroupedRule {
+  title: string;
+  ungrouped: GroupedItem[];
+  scopes: Map<string, GroupedItem[]>;
+}
+export interface GroupedItem {
+  parsed: ParsedCommit;
+  text: string;
+  /** Description paragraphs; each becomes one nested bullet with wrapped continuations. */
+  bodyParagraphs: string[][];
+}
+/** A `## <version>` section parsed out of an existing changelog. */
+export interface ExistingEntry {
+  version: string;
+  bullets: string[];
+}
+//#endregion

package/dist/packages/changelog/src/utils/version.d.ts

@@ -0,0 +1,6 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/changelog/src/utils/version.d.ts
+/** Render a `## <version> (Month Year)` heading + summary, optionally marked. */
+export declare function renderChangelogEntry(version: string, summary: string, date?: Date, withMarkers?: boolean, packageChanges?: string): string;
+//#endregion

package/dist/packages/changelog/src/utils/version.js

@@ -0,0 +1,14 @@
+import{resolve as e}from"node:path";import"node:url";import.meta.url;import{discoverWorkspaceDirs as t,repoRoot as n}from"./repo.js";import{existsSync as r,readFileSync as i,writeFileSync as a}from"node:fs";function o(e){return`${e.toLocaleString(`en-US`,{month:`long`})} ${e.getFullYear()}`}function s(e,t){let n=/^(\d+)\.(\d+)\.(\d+)/.exec(e);if(!n)throw Error(`Cannot parse version "${e}"`);let r=Number(n[1]),i=Number(n[2]),a=Number(n[3]);return t===`major`?(r+=1,i=0,a=0):t===`minor`?(i+=1,a=0):a+=1,`${r}.${i}.${a}`}function c(e,t,n,r=!0,i=``){let a=n?` (${o(n)})`:``,s=i?`${t}\n\n${i}`:t;return r?`## ${e}${a}
+
+<!-- release:start -->
+
+${s}
+
+<!-- release:end -->`:`## ${e}${a}\n\n${s}`}function l(e,t){let n=e.split(`
+`).filter(e=>!e.includes(`<!-- release:start -->`)&&!e.includes(`<!-- release:end -->`)).join(`
+`).trimEnd().replace(/\n{3,}/g,`
+
+`),r=n.split(`
+`),i=r[0],a;return a=i!==void 0&&i.startsWith(`# `)?[i,``,t.trimEnd(),``,...r.slice(1)].join(`
+`):`${t.trimEnd()}\n\n${n}`,`${a.trimEnd()}\n`}function u(e,t){let n=r(e)?i(e,`utf8`):`# Changelog
+`;a(e,l(n,t),`utf8`)}function d(o,s){let c=n(),l=[e(c,`CHANGELOG.md`),...t().map(t=>e(t,`CHANGELOG.md`))];for(let e of l){if(!r(e))continue;let t=i(e,`utf8`),n=t.replace(`## ${o}`,`## ${s}`);n!==t&&(a(e,n,`utf8`),console.log(`  retagged ${e}`))}}export{s as bumpVersion,l as insertNewEntry,o as monthYear,u as prependChangelogEntry,c as renderChangelogEntry,d as retagChangelogs};

package/dist/packages/changelog/src/utils/write.js

@@ -0,0 +1 @@
+import{relative as e,resolve as t}from"node:path";import"node:url";import.meta.url;import{readCommits as n,repoSlug as r}from"./git.js";import{discoverWorkspaceDirs as i,repoRoot as a}from"./repo.js";import{packageChangesForCurrent as o}from"./packages.js";import{formatChangelogFile as s}from"./format.js";import{prependChangelogEntry as c,renderChangelogEntry as l}from"./version.js";import{parseExistingChangelog as u,reformatRootChangelog as d}from"./reformat.js";import{buildSummary as f}from"./summary.js";import{existsSync as p,readFileSync as m,writeFileSync as h}from"node:fs";function g(g,_,v,y,b,x=!1){let S=a(),C=r(),w=t(S,`CHANGELOG.md`),T=``;if(x&&p(w)){let e=u(m(w,`utf8`))[0];e&&(T=o(e.version))}if(b){let e=d(x);e&&(h(w,e,`utf8`),console.log(`  reformatted ${w}`))}let E=l(g,y,/* @__PURE__ */ new Date,!0,T);c(w,E),console.log(`  updated ${w}`);for(let r of i()){if(t(r)===t(S))continue;let i=t(r,`CHANGELOG.md`);if(!p(i))continue;let a=e(S,r).replace(/\\/g,`/`),o=n(_,a);if(o.length===0){console.log(`  skipped ${i} (no commits in ${a})`);continue}let s=f(o);c(i,l(g,s,/* @__PURE__ */ new Date)),console.log(`  updated ${i}`)}for(let e of[t(S,`CHANGELOG.md`),...i().filter(e=>t(e)!==t(S)).map(e=>t(e,`CHANGELOG.md`)).filter(e=>p(e))])s(e,C)}export{g as writeChangelogs};

package/dist/packages/changelog/src/workflows.d.ts

@@ -0,0 +1,53 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Replacements } from "../../shared/src/template.js";
+import { WorkflowConfig, WorkflowSetting, WorkflowStep } from "../../shared/src/config-schema.js";
+import "../../shared/src/index.js";
+//#region packages/changelog/src/workflows.d.ts
+export interface WorkflowJob {
+  name?: string;
+  'runs-on': string;
+  if?: string;
+  needs?: string | string[];
+  /** A GitHub environment name (matched by the OIDC trusted publisher). */
+  environment?: string;
+  permissions?: Record<string, string>;
+  env?: Record<string, string>;
+  outputs?: Record<string, string>;
+  steps: WorkflowStep[];
+}
+export interface Workflow {
+  name: string;
+  on: Record<string, unknown>;
+  permissions?: Record<string, string>;
+  concurrency?: unknown;
+  env?: Record<string, string>;
+  jobs: Record<string, WorkflowJob>;
+  [key: string]: unknown;
+}
+/** The default replacement values for the workflow templates. */
+export declare const DEFAULT_WORKFLOW_TOKENS: Replacements;
+/** The workflow ids the builder knows about. */
+export type WorkflowId = 'ci' | 'changelog' | 'release' | 'sync' | 'issues';
+/** Default file name per workflow id. */
+export declare const WORKFLOW_FILENAMES: Record<WorkflowId, string>;
+/** Whether a workflow setting enables the workflow (default true). */
+export declare function isEnabled(setting: WorkflowSetting | undefined): boolean;
+/** Build all default workflows for a set of tokens. */
+export declare function defaultWorkflows(tokens: Replacements): Record<WorkflowId, Workflow>;
+/** Merge a consumer's {@link WorkflowConfig} over a default workflow. */
+export declare function applyWorkflowConfig(workflow: Workflow, config?: WorkflowConfig): Workflow;
+export interface RenderWorkflowOptions {
+  /** Base replacement tokens (merged with the workflow's own `tokens`). */
+  tokens: Replacements;
+  /** The consumer's per-workflow config. */
+  config?: WorkflowConfig;
+}
+/**
+ * Build one workflow as a YAML string, applying the consumer's config. Returns
+ * `undefined` when the workflow is disabled.
+ */
+export declare function renderWorkflow(id: WorkflowId, options: RenderWorkflowOptions): string | undefined;
+/** Render every workflow, keyed by file name (disabled ones are omitted). */
+export declare function renderWorkflows(tokens: Replacements, workflows?: Partial<Record<WorkflowId, WorkflowSetting>>): Record<string, string>;
+//#endregion

package/dist/packages/changelog/src/workflows.js

@@ -0,0 +1,5 @@
+import"node:path";import"node:url";import.meta.url;import{applyReplacementsDeep as e}from"../../shared/src/template.js";import{toYaml as t}from"../../shared/src/yaml.js";import"../../shared/src/index.js";const n={nodeVersion:`22`,yarnVersion:`4.17.1`,packageManager:`yarn`,mainBranch:`main`,devBranch:`dev`,tooling:`dbx`},r={ci:`ci.yml`,changelog:`changelog.yml`,release:`release.yml`,sync:`sync.yml`,issues:`issues.yml`};function i(e){return e===void 0?!0:typeof e==`boolean`?e:e.enabled!==!1}function a(e){return`${e.packageManager} ${e.tooling}`}function o(e){return[{name:`Checkout`,uses:`actions/checkout@v4`,with:{"fetch-depth":0,token:"${{ secrets.GITHUB_TOKEN }}"}},{name:`Setup Node`,uses:`actions/setup-node@v4`,with:{"node-version":String(e.nodeVersion)}},{name:`Enable Corepack`,run:`corepack enable\ncorepack prepare ${e.packageManager}@${e.yarnVersion} --activate`},{name:`Install dependencies`,run:`${e.packageManager} install --immutable`}]}function s(e){let t=a(e),n=String(e.mainBranch),r=String(e.devBranch);return{ci:{name:`CI`,on:{push:{branches:[n]},pull_request:{branches:[`release/**`,`feat/**`,`feature/**`,`fix/**`,`chore/**`]}},jobs:{ci:{"runs-on":`ubuntu-latest`,steps:[...o(e),{name:`Commitlint (Conventional Commits)`,if:"${{ github.event_name == 'pull_request' || github.event.before != '0000000000000000000000000000000000000000' }}",run:`set -euo pipefail\nbase="\${{ github.event.pull_request.base.sha || github.event.before }}"\nhead="\${{ github.event.pull_request.head.sha || github.event.after }}"\n${e.packageManager} commitlint --from "$base" --to "$head"`},{name:`Verify generated files are in sync`,run:`${t} sync --check`},{name:`Build`,run:`${e.packageManager} build`}]}}},changelog:{name:`Changelog (dev)`,on:{push:{branches:[r]}},permissions:{contents:`write`},concurrency:{group:`changelog-dev`,"cancel-in-progress":!1},jobs:{"generate-changelog":{"runs-on":`ubuntu-latest`,if:`!startsWith(github.event.head_commit.message, 'chore: version packages ') && !startsWith(github.event.head_commit.message, 'release: ')`,env:{GITHUB_TOKEN:"${{ secrets.GITHUB_TOKEN }}"},steps:[...o(e),{name:`Generate changelog + bump versions`,env:{GITHUB_TOKEN:"${{ secrets.GITHUB_TOKEN }}"},run:[`set -euo pipefail`,'after="${{ github.event.after }}"; [ -n "$after" ] || after="HEAD"',`boundary="$(git log --format=%H --grep='^chore: version packages ' -1 || true)"`,`if [ -n "$boundary" ]; then range="$boundary..$after"; else range="$after"; fi`,`${t} changelog --range "$range"`].join(`
+`)},{name:`Commit + push changelog updates`,env:{GITHUB_TOKEN:"${{ secrets.GITHUB_TOKEN }}"},run:[`set -euo pipefail`,`git diff --quiet && { echo "No changelog changes."; exit 0; }`,`git config user.name "github-actions[bot]"`,`git config user.email "41898282+github-actions[bot]@users.noreply.github.com"`,`git add -u -- "*package.json" "*CHANGELOG.md"`,`git commit -m "chore: version packages ($(node -p "require('./package.json').version"))"`,`git push origin ${r}`].join(`
+`)}]}}},release:{name:`Release`,on:{push:{branches:[n]},workflow_dispatch:null},permissions:{contents:`write`,"pull-requests":`write`},concurrency:{group:`release`,"cancel-in-progress":!1},jobs:{"create-release-pr":{"runs-on":`ubuntu-latest`,if:`(github.event_name == 'push' || github.event_name == 'workflow_dispatch') && !startsWith(github.event.head_commit.message, 'chore: version packages ') && !startsWith(github.event.head_commit.message, 'release: ')`,env:{GITHUB_TOKEN:"${{ secrets.GITHUB_TOKEN }}"},steps:[...o(e),{name:`Open release PR`,env:{GITHUB_TOKEN:"${{ secrets.GITHUB_TOKEN }}"},run:[`set -euo pipefail`,`version="$(node -p "require('./package.json').version")"`,`branch="release/$version"`,`if git ls-remote --exit-code --heads origin "$branch" >/dev/null 2>&1; then`,`  echo "Release PR already open for $version."; exit 0`,`fi`,`git config user.name "github-actions[bot]"`,`git config user.email "41898282+github-actions[bot]@users.noreply.github.com"`,`git checkout -b "$branch"`,`git add -A`,`git commit -m "chore: version packages ($version)" || true`,`git push origin "$branch"`,`notes="$(awk '/<!-- release:start -->/{f=1;next} /<!-- release:end -->/{exit} f{print}' CHANGELOG.md 2>/dev/null || true)"`,`[ -n "$notes" ] || notes="Release $version"`,`gh pr create --base ${n} --head "$branch" --title "release: $version" --body "$notes"`].join(`
+`)}]}}},sync:{name:`Tooling sync`,on:{push:{branches:[n,r]},pull_request:null},jobs:{sync:{"runs-on":`ubuntu-latest`,steps:[...o(e),{name:`Verify generated files are in sync`,run:`${t} sync --check`}]}}},issues:{name:`Issues`,on:{issues:{types:[`opened`]}},permissions:{issues:`write`},jobs:{"enforce-title":{"runs-on":`ubuntu-latest`,steps:[{name:`Check and rename issue title`,env:{GH_TOKEN:"${{ github.token }}",ISSUE_NUMBER:"${{ github.event.issue.number }}"},run:[`set -euo pipefail`,`labels=$(gh issue view "$ISSUE_NUMBER" --json labels -q '.labels[].name' || true)`,`title=$(gh issue view "$ISSUE_NUMBER" --json title -q '.title')`,`type=""`,`for label in $labels; do case "$label" in *bug*) type="bug" ;; esac; done`,`if [ -z "$type" ]; then for label in $labels; do case "$label" in *enhancement*|*feature*|*feat*) type="feat" ;; esac; done; fi`,`if [ -z "$type" ]; then echo "No bug/enhancement label on issue #$ISSUE_NUMBER; skipping."; exit 0; fi`,`prefix="[bug]"; [ "$type" = "feat" ] && prefix="[feat]"`,`stripped=$(printf '%s' "$title" | sed -E 's/^\\[(bug|feat)\\] *//i')`,`new_title="$prefix $stripped"`,`if [ "$new_title" = "$title" ]; then echo "Issue #$ISSUE_NUMBER title already conforms."; exit 0; fi`,`gh issue edit "$ISSUE_NUMBER" --title "$new_title"`].join(`
+`)}]}}}}}function c(e){return e.steps?Array.isArray(e.steps)?e.steps:[e.steps]:[]}function l(e,t={}){let n=structuredClone(e);if(t.pushBranches){let e=n.on.push??{};n.on.push={...e,branches:t.pushBranches}}if(t.pullRequestBranches){let e=n.on.pull_request??{};n.on.pull_request={...e,branches:t.pullRequestBranches}}t.triggers&&(n.on={...n.on,...t.triggers}),t.extra&&Object.assign(n,t.extra),t.jobs&&(n.jobs={...n.jobs,...t.jobs});let r=Object.keys(n.jobs)[0];for(let e of c(t)){let t=e.job??r;if(!t)continue;let i=n.jobs[t];i&&(i.steps=[...e.before??[],...i.steps,...e.after??[]])}return n}function u(r,i){let a=i.config??{};if(a.enabled===!1)return;let o={...n,...i.tokens,...a.tokens},c=s(o)[r],u=e(l(c,a),o);return t(u)}function d(e,t={}){let n={};for(let a of Object.keys(r)){let o=t[a];if(!i(o))continue;let s=u(a,{tokens:e,config:typeof o==`object`?o:{}});s&&(n[r[a]]=s)}return n}export{n as DEFAULT_WORKFLOW_TOKENS,r as WORKFLOW_FILENAMES,l as applyWorkflowConfig,s as defaultWorkflows,i as isEnabled,u as renderWorkflow,d as renderWorkflows};

package/dist/packages/config/src/cli/index.d.ts

@@ -0,0 +1,28 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ToolingCommand } from "../../../shared/src/types.js";
+import "../../../shared/src/index.js";
+import { ConfigEngine } from "../engine.js";
+//#region packages/config/src/cli/index.d.ts
+/** Default output locations for the config commands. */
+export interface ConfigCommandDefaults {
+  /** Where `.env.example[.dev]` are written (default: engine root). */
+  envDir?: string;
+  /** Where the config + env types are written. */
+  typesDir?: string;
+  /** Where the markdown reference is written. */
+  docsDir?: string;
+  /** The JSON Schema output path. */
+  schemaPath?: string;
+  /** The config metadata output path. */
+  configJsonPath?: string;
+  /** The CLI options output path. */
+  cliOptionsPath?: string;
+}
+export interface ConfigCommandContext {
+  engine: ConfigEngine;
+  defaults?: ConfigCommandDefaults;
+}
+/** Build the config commands bound to a consumer's engine. */
+export declare function configCommands(ctx: ConfigCommandContext): ToolingCommand[];
+//#endregion

package/dist/packages/config/src/cli/index.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import t from"node:fs";function n(t,n){return e.resolve(t??n)}function r(r){let{engine:i}=r,a=r.defaults??{};return[{name:`config:env`,description:`Generate .env.example from the config schemas.`,options:[{flags:`-o, --out <dir>`,description:`Output directory.`}],run:({out:t})=>{let r=e.join(n(t,a.envDir??i.root),`.env.example`);i.writeEnvFile({output:r}),console.log(`Generated ${e.relative(process.cwd(),r)}`)}},{name:`config:types`,description:`Generate the config and env types.`,options:[{flags:`-o, --out <dir>`,description:`Output directory.`},{flags:`--env`,description:`Also write the env type files.`}],run:({out:t,env:r})=>{let o=n(t,a.typesDir??i.root),s=i.writeConfigTypes({outputDir:o});r&&s.push(...i.writeEnvTypes({outputDir:o}));for(let t of s)console.log(`Generated ${e.relative(process.cwd(),t)}`)}},{name:`config:json`,description:`Generate the config metadata JSON.`,options:[{flags:`-o, --out <file>`,description:`Output file.`}],run:({out:r})=>{let o=n(r,a.configJsonPath??e.join(i.root,`config.json`)),s=i.buildConfigJson();t.mkdirSync(e.dirname(o),{recursive:!0}),t.writeFileSync(o,`${JSON.stringify(s,null,4)}\n`,`utf-8`),console.log(`Generated ${e.relative(process.cwd(),o)}`)}},{name:`config:schema`,description:`Generate the untyped JSON Schema.`,options:[{flags:`-o, --out <file>`,description:`Output file.`}],run:async({out:t})=>{let r=n(t,a.schemaPath??e.join(i.root,`config.schema.json`));await i.writeJsonSchema({output:r}),console.log(`Generated ${e.relative(process.cwd(),r)}`)}},{name:`config:markdown`,description:`Generate the markdown configuration reference.`,options:[{flags:`-o, --out <dir>`,description:`Output directory.`}],run:({out:t})=>{let r=n(t,a.docsDir??e.join(i.root,`docs/reference/configuration`)),o=i.writeMarkdown({outDir:r});for(let t of o)console.log(`Generated ${e.relative(process.cwd(),t)}`)}},{name:`config:cli`,description:`Generate the CLI options JSON.`,options:[{flags:`-o, --out <file>`,description:`Output file.`}],run:({out:t})=>{let r=n(t,a.cliOptionsPath??e.join(i.root,`cli-options.json`));i.generateCliOptions({output:r}),console.log(`Generated ${e.relative(process.cwd(),r)}`)}},{name:`config:all`,description:`Run every config generator.`,options:[{flags:`-o, --out <dir>`,description:`Base output directory.`}],run:async({out:t})=>{let r=n(t,i.root),a=[];a.push(i.writeEnvFile({output:e.join(r,`.env.example`)})),a.push(...i.writeConfigTypes({outputDir:e.join(r,`types`)}),...i.writeEnvTypes({outputDir:e.join(r,`types`)}),...i.writeMarkdown({outDir:e.join(r,`docs/reference/configuration`)})),a.push(await i.writeJsonSchema({output:e.join(r,`config.schema.json`)})),a.push(i.generateCliOptions({output:e.join(r,`cli-options.json`)}));for(let t of a.filter(e=>typeof e==`string`))console.log(`Generated ${e.relative(process.cwd(),t)}`)}}]}export{r as configCommands};

package/dist/packages/config/src/collect.d.ts

@@ -0,0 +1,19 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes, EnvVarDef } from "./types.js";
+//#region packages/config/src/collect.d.ts
+/** The default env-var prefix used when none is configured. */
+export declare const DEFAULT_ENV_PREFIX = "APP_";
+/** Options for {@link collectEnvVars}. */
+export interface CollectEnvVarsOptions {
+  /**
+   * Custom env-name -> dotted-path derivation, used when a leaf does not set
+   * an explicit `path` (eg. to handle dual `PROXIFIED_`/`VITE_` prefixes).
+   */
+  envPathOf?: (env: string) => string;
+}
+/** Collect every env-var-backed leaf from the scope schemas. */
+export declare function collectEnvVars(scopes: ConfigScopes, envPrefix?: string, options?: CollectEnvVarsOptions): EnvVarDef[];
+/** Collect the env var names marked `required` for a scope. */
+export declare function collectRequiredEnvVars(scopes: ConfigScopes, scope: string, envPrefix?: string, options?: CollectEnvVarsOptions): string[];
+//#endregion

package/dist/packages/config/src/collect.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{envMetaOf as e}from"./schema.js";import{envPathOf as t}from"./types.js";const n=`APP_`;function r(e){let t=Array.isArray(e)?e:[e];if(t.includes(`array`))return`array`;if(t.includes(`object`))return`object`;if(t.includes(`boolean`))return`boolean`;if(t.includes(`number`))return`number`;if(t.includes(`string`))return`string`}function i(n,a,o,s){let c=e(n);if(c?.env){let e;try{e=n.toJSONSchema?.()}catch{}a.push({name:c.env,path:c.path??s.envPathOf?.(c.env)??t(c.env,o),...c.description?{description:c.description}:{},...e?.default===void 0?{}:{default:e.default},...c.required?{required:!0}:{},...c.secret?{secret:!0}:{},scope:c.scope??`default`,...c.public?{public:!0}:{},...r(e?.type)?{envType:r(e?.type)}:{}});return}let l=n.shape;if(l)for(let e of Object.values(l))i(e,a,o,s)}function a(e,t=n,r={}){let a=[];for(let[n,o]of Object.entries(e)){let e=a.length;i(o.zodSchema,a,t,r);for(let t=e;t<a.length;t++)(!a[t].scope||a[t].scope==="default")&&(a[t].scope=n)}return a}function o(e,t,r=n,i={}){return a(e,r,i).filter(e=>e.scope===t&&e.required).map(e=>e.name)}export{n as DEFAULT_ENV_PREFIX,a as collectEnvVars,o as collectRequiredEnvVars};

package/dist/packages/config/src/config-json.d.ts

@@ -0,0 +1,33 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "./types.js";
+import { CollectEnvVarsOptions } from "./collect.js";
+//#region packages/config/src/config-json.d.ts
+/** A serialized env var entry in `config.json`. */
+export interface ConfigJsonEntry {
+  name: string;
+  path: string;
+  scope: string;
+  description?: string;
+  default?: unknown;
+  required?: boolean;
+  secret?: boolean;
+  public?: boolean;
+}
+/** The generated config metadata document (`config.json`). */
+export interface ConfigJsonDoc {
+  $comment: string;
+  version: number;
+  env: ConfigJsonEntry[];
+}
+export interface BuildConfigJsonOptions {
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** Override the `$comment` banner. */
+  comment?: string;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/** Build the config metadata JSON document. */
+export declare function buildConfigJson(scopes: ConfigScopes, options?: BuildConfigJsonOptions): ConfigJsonDoc;
+//#endregion

package/dist/packages/config/src/config-json.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{collectEnvVars as e}from"./collect.js";function t(t,n={}){let r=e(t,n.envPrefix,{envPathOf:n.envPathOf});return{$comment:n.comment??`Generated from the config engine — edit the config schemas instead.`,version:1,env:r.map(e=>({name:e.name,path:e.path,scope:e.scope,...e.description?{description:e.description}:{},...e.default===void 0?{}:{default:e.default},...e.required?{required:!0}:{},...e.secret?{secret:!0}:{},...e.public?{public:!0}:{}}))}}export{t as buildConfigJson};

package/dist/packages/config/src/engine.d.ts

@@ -0,0 +1,56 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigEngineOptions, ConfigScopes, EnvVarDef } from "./types.js";
+import { BuildConfigJsonOptions, ConfigJsonDoc } from "./config-json.js";
+import { EnvFileOptions } from "./env-file.js";
+import { CliOptionDef, GenerateCliOptionsOptions } from "./generators/cli.js";
+import { GenerateEnvTypesOptions } from "./generators/env.js";
+import { GenerateJsonSchemaOptions } from "./generators/json.js";
+import { GenerateMarkdownOptions } from "./generators/markdown.js";
+import { GenerateTypesOptions } from "./generators/types.js";
+//#region packages/config/src/engine.d.ts
+/** The bound, reusable config engine. */
+export interface ConfigEngine {
+  readonly scopes: ConfigScopes;
+  readonly envPrefix: string;
+  readonly baseGroup: string;
+  readonly root: string;
+  /** Every env-var-backed leaf across the registered scopes. */
+  collectEnvVars(): EnvVarDef[];
+  /** The names of the required env vars for a scope. */
+  requiredEnvVars(scope: string): string[];
+  /** Render `.env` content. */
+  renderEnvFile(options?: EnvFileOptions): string;
+  /** Write a `.env` file. Returns the path written. */
+  writeEnvFile(options: EnvFileOptions & {
+    output: string;
+  }): string;
+  /** Build the config metadata JSON document. */
+  buildConfigJson(options?: BuildConfigJsonOptions): ConfigJsonDoc;
+  /** Build (and optionally write) the untyped JSON Schema document. */
+  generateJsonSchema(options?: GenerateJsonSchemaOptions): Promise<Record<string, unknown>>;
+  /** Write the JSON Schema document. Returns the path written. */
+  writeJsonSchema(options: GenerateJsonSchemaOptions & {
+    output: string;
+  }): Promise<string>;
+  /** Render every config type file, keyed by scope name. */
+  renderConfigTypes(options?: GenerateTypesOptions): Record<string, string>;
+  /** Write the config type files into `outputDir`. */
+  writeConfigTypes(options: GenerateTypesOptions & {
+    outputDir: string;
+  }): string[];
+  /** Write the env type files into `outputDir`. */
+  writeEnvTypes(options: GenerateEnvTypesOptions & {
+    outputDir: string;
+  }): string[];
+  /** Write the markdown reference into `outDir`. */
+  writeMarkdown(options: GenerateMarkdownOptions & {
+    outDir: string;
+  }): string[];
+  /** Generate (and optionally write) the CLI option definitions. */
+  generateCliOptions(options?: GenerateCliOptionsOptions): CliOptionDef[];
+}
+/** Create a reusable config engine. */
+export declare function createConfigEngine(options: ConfigEngineOptions): ConfigEngine;
+//#endregion
+export type { ConfigEngineOptions, ConfigScopes };

package/dist/packages/config/src/engine.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{collectEnvVars as t,collectRequiredEnvVars as n}from"./collect.js";import{buildConfigJson as r}from"./config-json.js";import{generateEnvFile as i}from"./env-file.js";import{generateCliOptions as a}from"./generators/cli.js";import{generateEnvTypes as o}from"./generators/env.js";import{generateConfigJsonSchema as s,generateJsonSchemaFile as c}from"./generators/json.js";import{generateConfigMarkdown as l}from"./generators/markdown.js";import{generateConfigTypes as u,renderAllConfigTypes as d}from"./generators/types.js";import{findProjectRoot as f}from"./root.js";import p from"node:fs";function m(m){let h=m.scopes,g=m.envPrefix??`APP_`,_=m.baseGroup??`base`,v=m.root??f(),y=m.envPathOf;return{scopes:h,envPrefix:g,baseGroup:_,root:v,collectEnvVars:()=>t(h,g,{envPathOf:y}),requiredEnvVars:e=>n(h,e,g,{envPathOf:y}),renderEnvFile:(e={})=>i(h,{envPrefix:g,envPathOf:y,...e}),writeEnvFile:t=>{let n=i(h,{envPrefix:g,envPathOf:y,...t});return p.mkdirSync(e.dirname(t.output),{recursive:!0}),p.writeFileSync(t.output,n,`utf-8`),t.output},buildConfigJson:(e={})=>r(h,{envPrefix:g,envPathOf:y,...e}),generateJsonSchema:(e={})=>s(h,{baseGroup:_,...e}),writeJsonSchema:e=>c(h,{baseGroup:_,...e}),renderConfigTypes:(e={})=>d(h,{baseGroup:_,...e}),writeConfigTypes:e=>u(h,{baseGroup:_,...e}),writeEnvTypes:e=>o(h,{envPrefix:g,envPathOf:y,...e}),writeMarkdown:e=>l(h,{baseGroup:_,envPrefix:g,envPathOf:y,...e}),generateCliOptions:(e={})=>a(h,{envPrefix:g,envPathOf:y,...e})}}export{m as createConfigEngine};

package/dist/packages/config/src/env-file.d.ts

@@ -0,0 +1,33 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "./types.js";
+import { CollectEnvVarsOptions } from "./collect.js";
+//#region packages/config/src/env-file.d.ts
+export interface EnvFileOptions {
+  /** Env vars to include (defaults to all). */
+  include?: string[];
+  /** Env vars to exclude. */
+  exclude?: string[];
+  /** Default values to inject (overrides the schema defaults). */
+  values?: Record<string, string>;
+  /** Comment banner placed at the top of the file. */
+  header?: string;
+  /** Only emit these scopes (defaults to every registered scope). */
+  scopes?: string[];
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** Omit descriptions (emit bare assignments). */
+  bare?: boolean;
+  /** Extra raw `NAME=value` lines appended after the schema vars. */
+  extra?: Record<string, string>;
+  /** The characters wrapping a scope's section header (default `----`). */
+  scopeSeparator?: string;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/**
+ * Generate `.env` content from the config schemas. Secrets and required-without-
+ * default vars are emitted blank so operators fill them in.
+ */
+export declare function generateEnvFile(scopes: ConfigScopes, options?: EnvFileOptions): string;
+//#endregion

package/dist/packages/config/src/env-file.js

@@ -0,0 +1,3 @@
+import"node:path";import"node:url";import.meta.url;import{collectEnvVars as e}from"./collect.js";function t(e){let t=e.default;return Array.isArray(t)?t.join(`,`):typeof t==`boolean`?t?`true`:`false`:typeof t==`number`?String(t):typeof t==`object`&&t?JSON.stringify(t):t===void 0?``:String(t)}function n(n,r={}){let i=r.envPrefix??`APP_`,a=r.scopeSeparator??`----`,o=e(n,i,{envPathOf:r.envPathOf}),s=r.scopes??Object.keys(n),c=o.filter(e=>s.includes(e.scope)&&(!r.include||r.include.includes(e.name))&&!r.exclude?.includes(e.name)),l=[];r.header&&l.push(r.header,``);let u;for(let e of c){if(e.scope!==u&&(u!==void 0&&l.push(``),l.push(`# ${a} ${e.scope.toUpperCase()} ${a}`),u=e.scope),!r.bare&&e.description)for(let t of e.description.split(`
+`))l.push(`# ${t}`);let n=r.values?.[e.name];e.secret&&n===void 0?l.push(`# ${e.name}=`):l.push(`${e.name}=${n??t(e)}`)}if(r.extra){let e=Object.entries(r.extra).filter(([e])=>!c.some(t=>t.name===e)).map(([e,t])=>`${e}=${t}`);e.length&&l.push(``,`# ${a} EXTRA ${a}`,...e)}return`${l.join(`
+`)}\n`}export{n as generateEnvFile};

package/dist/packages/config/src/env.d.ts

@@ -0,0 +1,31 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/config/src/env.d.ts
+/**
+ * Low-level configuration helpers: env-tree parsing, typed accessors and
+ * override merging. Free of Node builtins so browser consumers can import the
+ * frontend resolver without pulling `node:path` / `node:url` into a bundle.
+ */
+/** A flat env source (process.env, import.meta.env or a plain object). */
+export type EnvSource = Record<string, string | undefined>;
+/** A nested tree produced by folding `PREFIX_*` vars on `_`. */
+export type EnvTree = Record<string, unknown>;
+/** Parse a flat env source into the nested `PREFIX_*` tree. */
+export declare function parseEnvTree(env?: EnvSource, prefix?: string): EnvTree;
+/** Read a dotted path out of an env tree. */
+export declare function readEnvPath(tree: EnvTree, path: string): unknown;
+/** Read a string value, falling back when unset or empty. */
+export declare function envString(tree: EnvTree, path: string, fallback?: string): string;
+/** Read an integer value, falling back when unset or not a number. */
+export declare function envInt(tree: EnvTree, path: string, fallback: number): number;
+/** Read a boolean value. Accepts true/false/1/0/yes/no/on/off. */
+export declare function envBool(tree: EnvTree, path: string, fallback: boolean): boolean;
+/** Read a comma-separated list, filtering empty entries. */
+export declare function envList(tree: EnvTree, path: string, fallback?: string[]): string[];
+/** Read `Header=value,...` into a lowercase-keyed record. */
+export declare function envMap(tree: EnvTree, path: string): Record<string, string>;
+/** Recursively merge typed overrides over a base object (shallow per level). */
+export declare function applyOverrides<T extends object>(base: T, overrides?: Partial<T>): T;
+/** Trim trailing slashes from a URL-ish string. */
+export declare function trimTrailingSlashes(value: string): string;
+//#endregion

package/dist/packages/config/src/env.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e={},t=`APP_`){let n={};for(let[r,i]of Object.entries(e)){if(!r.startsWith(t)||i===void 0)continue;let e=r.slice(t.length).toLowerCase().split(`_`),a=n;for(let t=0;t<e.length-1;t+=1){let n=e[t]??``;(typeof a[n]!=`object`||a[n]===null)&&(a[n]={}),a=a[n]}a[e[e.length-1]??``]=i}return n}function t(e,t){let n=e;for(let e of t.split(`.`)){if(typeof n!=`object`||!n)return;n=n[e]}return n}function n(e,n,r=``){let i=t(e,n);return typeof i==`string`&&i.trim()!==``?i:r}function r(e,n,r){let i=t(e,n);if(typeof i!=`string`||i.trim()===``)return r;let a=Number.parseInt(i,10);return Number.isFinite(a)?a:r}function i(e,n,r){let i=t(e,n);if(typeof i!=`string`||i.trim()===``)return r;let a=i.trim().toLowerCase();return[`true`,`1`,`yes`,`on`].includes(a)?!0:![`false`,`0`,`no`,`off`].includes(a)&&r}function a(e,n,r=[]){let i=t(e,n);return typeof i!=`string`||i.trim()===``?r:i.split(`,`).map(e=>e.trim()).filter(Boolean)}function o(e,t){let n={};for(let r of a(e,t,[])){let e=r.indexOf(`=`);e!==-1&&(n[r.slice(0,e).trim().toLowerCase()]=r.slice(e+1).trim())}return n}function s(e,t){if(!t)return e;let n={...e};for(let[r,i]of Object.entries(t)){if(i===void 0)continue;let t=e[r];n[r]=t&&typeof t==`object`&&!Array.isArray(t)&&i&&typeof i==`object`&&!Array.isArray(i)?s(t,i):i}return n}function c(e){return e.replace(/\/+$/,``)}export{s as applyOverrides,i as envBool,r as envInt,a as envList,o as envMap,n as envString,e as parseEnvTree,t as readEnvPath,c as trimTrailingSlashes};

package/dist/packages/config/src/generators/cli.d.ts

@@ -0,0 +1,78 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+import { CollectEnvVarsOptions } from "../collect.js";
+import { ParseArgsOptionsConfig } from "node:util";
+//#region packages/config/src/generators/cli.d.ts
+/** Flag-shaping options shared by every CLI helper. */
+export interface CliFlagOptions {
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** Shorthand flags keyed by env var name (eg. `{ APP_TOKEN: 't' }`). */
+  shortFlags?: Record<string, string>;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/** A generated CLI option definition for one env var. */
+export interface CliOptionDef {
+  /** CLI flag, e.g. `--base-url`. */
+  flag: string;
+  /** Shorthand flag, e.g. `-u`. */
+  short?: string;
+  /** The env var the flag reads, e.g. `APP_CLI_BASE_URL`. */
+  env: string;
+  /** The resolved value type (`string`, `number`, `boolean`, ...). */
+  type: string;
+  /** Human-readable description. */
+  description?: string;
+  /** Never echo a real value for this option (secrets). */
+  secret?: boolean;
+  /** The resolved default value, when one is configured. */
+  default?: string;
+}
+/** The long flag name (without dashes) for an env var. */
+export declare function flagOf(env: string, options?: CliFlagOptions): string;
+/** The long flag (e.g. `--base-url`) for an env var. */
+export declare function cliFlagOf(env: string, options?: CliFlagOptions): string;
+/** The shorthand flag (e.g. `-u`) for an env var, when configured. */
+export declare function cliShortOf(env: string, options?: CliFlagOptions): string | undefined;
+/** A flag label such as `-u, --base-url`. */
+export declare function cliFlagLabel(env: string, options?: CliFlagOptions): string;
+export interface GenerateCliOptionsOptions extends CliFlagOptions {
+  /** The scope whose env vars become flags (default `cli`). */
+  scope?: string;
+  /** Output file path to write the options as JSON. */
+  output?: string;
+}
+/** Generate the CLI option definitions for a scope's env vars. */
+export declare function generateCliOptions(scopes: ConfigScopes, options?: GenerateCliOptionsOptions): CliOptionDef[];
+/** The typed `values` of a parsed CLI args result. */
+export type CliArgsValues = Record<string, string | undefined>;
+/** A parsed CLI args result (node `parseArgs` output). */
+export interface CliArgsResult {
+  values: CliArgsValues;
+  positionals: string[];
+}
+/** A generated `node:util` `parseArgs` option entry. */
+export interface CliArgsOptionConfig {
+  type: 'string';
+  short?: string;
+  default?: string;
+}
+/** Build the `options` config for `node:util`'s `parseArgs`. */
+export declare function generateCliArgsOptions(defs: CliOptionDef[]): Record<string, CliArgsOptionConfig>;
+/** A generated CLI args parser bound to a set of option definitions. */
+export interface CliArgsParser {
+  options: ParseArgsOptionsConfig;
+  parse: (args?: string[]) => CliArgsResult;
+  /** Map a parsed result into a `{ [flag]: value }` record of provided flags. */
+  toConfig: (result?: CliArgsResult) => CliArgsValues;
+}
+/**
+ * Create a CLI args parser from generated option definitions. The generated
+ * `parse` uses `node:util`'s `parseArgs` and returns a typed result.
+ */
+export declare function createCliArgsParser(defs: CliOptionDef[], parseOptions?: {
+  strict?: boolean;
+}): CliArgsParser;
+//#endregion

package/dist/packages/config/src/generators/cli.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{formatCliFlag as e}from"../../../shared/src/string-utils.js";import"../../../shared/src/index.js";import{collectEnvVars as t}from"../collect.js";import n from"node:fs";import{parseArgs as r}from"node:util";function i(t,n={}){return e(t,n.envPrefix??`APP_`)}function a(e,t={}){return`--${i(e,t)}`}function o(e,t={}){let n=t.shortFlags?.[e];return n?`-${n}`:void 0}function s(e,t={}){let n=a(e,t),r=o(e,t);return r?`${r}, ${n}`:n}function c(e,r={}){let i=r.scope??`cli`,s=[];for(let n of t(e,r.envPrefix,{envPathOf:r.envPathOf}).filter(e=>e.scope===i)){let e=o(n.name,r);s.push({flag:a(n.name,r),env:n.name,type:n.envType??`string`,...e?{short:e}:{},...n.description?{description:n.description}:{},...n.secret?{secret:!0}:{},...n.default!==void 0&&!n.secret?{default:String(n.default)}:{}})}return r.output&&n.writeFileSync(r.output,`${JSON.stringify(s,null,4)}\n`,`utf-8`),s}function l(e){return Object.fromEntries(e.map(e=>[e.flag.replace(/^--/,``),{type:`string`,...e.short?{short:e.short.replace(/^-/,``)}:{},...e.default?{default:e.default}:{}}]))}function u(e,t){let n=l(e);return{options:n,parse:(e=process.argv.slice(2))=>r({args:e,options:n,strict:t?.strict??!0}),toConfig:e=>{let t=e?.values??{},n={};for(let[e,r]of Object.entries(t))r!==void 0&&(n[e]=r);return n}}}export{s as cliFlagLabel,a as cliFlagOf,o as cliShortOf,u as createCliArgsParser,i as flagOf,l as generateCliArgsOptions,c as generateCliOptions};

package/dist/packages/config/src/generators/env.d.ts

@@ -0,0 +1,42 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+import { CollectEnvVarsOptions } from "../collect.js";
+//#region packages/config/src/generators/env.d.ts
+export interface GenerateEnvTypesOptions {
+  /** Output directory. When omitted, nothing is written. */
+  outputDir?: string;
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** The `process.env` interface name (default `AppEnv`). */
+  envInterfaceName?: string;
+  /** The `import.meta.env` interface name (default `AppViteEnv`). */
+  viteEnvInterfaceName?: string;
+  /** The generated types file name (default `env.ts`). */
+  envFile?: string;
+  /** The generated ambient file name (default `env.d.ts`). */
+  dtsFile?: string;
+  /** The import specifier the `.d.ts` uses for the env types. */
+  importPath?: string;
+  /** A header comment prepended to both files. */
+  header?: string;
+  /** A raw (verbatim) header replacing the generated one in `env.ts`. */
+  envHeader?: string;
+  /** A raw (verbatim) header replacing the generated one in the `.d.ts`. */
+  dtsHeader?: string;
+  /** The doc comment above the `process.env` interface. */
+  envComment?: string;
+  /** Add a `declare module 'vite'` augmentation to the `.d.ts`. */
+  augmentVite?: boolean;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/** Render the `env.ts` content (the env + vite-env interfaces). */
+export declare function generateEnv(scopes: ConfigScopes, options?: GenerateEnvTypesOptions): string;
+/** Render the ambient `.d.ts` content. */
+export declare function generateEnvDts(options?: GenerateEnvTypesOptions): string;
+/** Generate `env.ts` + the ambient `.d.ts` into `outputDir`. Returns the paths. */
+export declare function generateEnvTypes(scopes: ConfigScopes, options: GenerateEnvTypesOptions & {
+  outputDir: string;
+}): string[];
+//#endregion

package/dist/packages/config/src/generators/env.js

@@ -0,0 +1,23 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{collectEnvVars as t}from"../collect.js";import n from"node:fs";function r(e){return e??`Generated env typing — DO NOT EDIT.`}function i(e,n={}){let i=n.envPrefix??`APP_`,a=n.envInterfaceName??`AppEnv`,o=n.viteEnvInterfaceName??`AppViteEnv`,s=t(e,i,{envPathOf:n.envPathOf}),c=s.filter(e=>e.scope!==`frontend`),l=s.filter(e=>e.public),u=n.envHeader?[n.envHeader,``]:[`/**`,` * ${r(n.header)}`,` */`,``];u.push(`/** ${n.envComment??"Environment variables typed on `process.env`."} */`,`export interface ${a} {`);for(let e of c)u.push(`    /** ${(e.description??``).replace(/\n/g,` `)} */`),u.push(`    ${e.name}?: string;`);u.push(`}`),u.push(``),u.push("/** Public frontend environment variables typed on `import.meta.env`. */"),u.push(`export interface ${o} {`);for(let e of l)u.push(`    /** ${(e.description??``).replace(/\n/g,` `)} */`),u.push(`    ${e.name}?: string;`);return u.push(`}`),`${u.join(`
+`).trimEnd()}\n`}function a(e={}){let t=e.envInterfaceName??`AppEnv`,n=e.viteEnvInterfaceName??`AppViteEnv`,i=e.importPath??`./env.js`;return`${e.dtsHeader?`${e.dtsHeader}\n`:`/**
+ * ${r(e.header)}
+ *
+ * Re-exports the generated env types onto \`process.env\` and
+ * \`import.meta.env\` so environment variables type-check everywhere.
+ */
+`}import type { ${t}, ${n} } from '${i}';
+
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv extends ${t} {}
+    }
+
+    interface ImportMetaEnv extends ${n} {}
+}${e.augmentVite?`
+
+declare module 'vite' {
+    interface ImportMetaEnv extends ${n} {}
+}`:``}
+
+export {};
+`}function o(t,r){let o=e.join(r.outputDir,r.envFile??`env.ts`),s=e.join(r.outputDir,r.dtsFile??`env.d.ts`);return n.mkdirSync(r.outputDir,{recursive:!0}),n.writeFileSync(o,i(t,r),`utf-8`),n.writeFileSync(s,a(r),`utf-8`),[o,s]}export{i as generateEnv,a as generateEnvDts,o as generateEnvTypes};

package/dist/packages/config/src/generators/index.d.ts

@@ -0,0 +1,8 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, GenerateCliOptionsOptions, cliFlagLabel, cliFlagOf, cliShortOf, createCliArgsParser, flagOf, generateCliArgsOptions, generateCliOptions } from "./cli.js";
+import { GenerateEnvTypesOptions, generateEnv, generateEnvDts, generateEnvTypes } from "./env.js";
+import { GenerateJsonSchemaOptions, generateConfigJsonSchema, generateJsonSchemaFile } from "./json.js";
+import { ConfigFileSection, GenerateMarkdownOptions, RenderConfigFileOptions, RenderMarkdownOptions, generateConfigMarkdown, renderConfigFileMarkdown, renderConfigIndex, renderScopeMarkdown } from "./markdown.js";
+import { GenerateTypesOptions, generateConfigTypes, renderAllConfigTypes, renderConfigTypes, resolveScopeSchema } from "./types.js";
+export { CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, ConfigFileSection, GenerateCliOptionsOptions, GenerateEnvTypesOptions, GenerateJsonSchemaOptions, GenerateMarkdownOptions, GenerateTypesOptions, RenderConfigFileOptions, RenderMarkdownOptions, cliFlagLabel, cliFlagOf, cliShortOf, createCliArgsParser, flagOf, generateCliArgsOptions, generateCliOptions, generateConfigJsonSchema, generateConfigMarkdown, generateConfigTypes, generateEnv, generateEnvDts, generateEnvTypes, generateJsonSchemaFile, renderAllConfigTypes, renderConfigFileMarkdown, renderConfigIndex, renderConfigTypes, renderScopeMarkdown, resolveScopeSchema };

package/dist/packages/config/src/generators/index.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{cliFlagLabel as e,cliFlagOf as t,cliShortOf as n,createCliArgsParser as r,flagOf as i,generateCliArgsOptions as a,generateCliOptions as o}from"./cli.js";import{generateEnv as s,generateEnvDts as c,generateEnvTypes as l}from"./env.js";import{generateConfigJsonSchema as u,generateJsonSchemaFile as d}from"./json.js";import{generateConfigMarkdown as f,renderConfigFileMarkdown as p,renderConfigIndex as m,renderScopeMarkdown as h}from"./markdown.js";import{generateConfigTypes as g,renderAllConfigTypes as _,renderConfigTypes as v,resolveScopeSchema as y}from"./types.js";export{e as cliFlagLabel,t as cliFlagOf,n as cliShortOf,r as createCliArgsParser,i as flagOf,a as generateCliArgsOptions,o as generateCliOptions,u as generateConfigJsonSchema,f as generateConfigMarkdown,g as generateConfigTypes,s as generateEnv,c as generateEnvDts,l as generateEnvTypes,d as generateJsonSchemaFile,_ as renderAllConfigTypes,p as renderConfigFileMarkdown,m as renderConfigIndex,v as renderConfigTypes,h as renderScopeMarkdown,y as resolveScopeSchema};

package/dist/packages/config/src/generators/json.d.ts

@@ -0,0 +1,24 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+//#region packages/config/src/generators/json.d.ts
+export interface GenerateJsonSchemaOptions {
+  /** Output file path. When omitted, nothing is written. */
+  output?: string;
+  /** The base group hoisted to the top level (default `base`). */
+  baseGroup?: string;
+  /** Document metadata overrides. */
+  id?: string;
+  title?: string;
+  description?: string;
+}
+/**
+ * Build the combined untyped JSON Schema document covering every scope, using
+ * untyped's `resolveSchema` on the definitions lowered from the Zod schemas.
+ */
+export declare function generateConfigJsonSchema(scopes: ConfigScopes, options?: GenerateJsonSchemaOptions): Promise<Record<string, unknown>>;
+/** Generate the JSON Schema document into `output`. Returns the path written. */
+export declare function generateJsonSchemaFile(scopes: ConfigScopes, options: GenerateJsonSchemaOptions & {
+  output: string;
+}): Promise<string>;
+//#endregion

package/dist/packages/config/src/generators/json.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{flattenBaseSchema as t,zodToUntypedDefinition as n}from"../schema.js";import r from"node:fs";import{resolveSchema as i}from"untyped";async function a(a,o={}){let s={};for(let[e,r]of Object.entries(a))s[e]=t(await i(n(r.zodSchema)),o.baseGroup);let c={$schema:`https://json-schema.org/draft/2020-12/schema`,$id:o.id??`https://example.com/schemas/config.json`,title:o.title??`Configuration`,description:o.description??`Every env-var-backed configuration value across all scopes.`,type:`object`,properties:s,required:Object.keys(a)};return o.output&&(r.mkdirSync(e.dirname(o.output),{recursive:!0}),r.writeFileSync(o.output,`${JSON.stringify(c,null,4)}\n`,`utf-8`)),c}async function o(e,t){return await a(e,t),t.output}export{a as generateConfigJsonSchema,o as generateJsonSchemaFile};