@advantacode/brander 0.2.0 → 0.3.0

package/README.md

@@ -1,5 +1,7 @@
 # AdvantaCode Brander
 
+[![npm](https://img.shields.io/npm/v/@advantacode/brander)](https://www.npmjs.com/package/@advantacode/brander)
+
 AdvantaCode Brander is a design token generator that produces consistent branding tokens for modern web applications.
 
 It converts a simple configuration into reusable outputs for multiple platforms including:
@@ -16,13 +18,13 @@ AdvantaCode Brander uses OKLCH color space to generate perceptually consistent c
 
 ```bash
 npm install -D @advantacode/brander
-npx --package @advantacode/brander advantacode-brander setup --out src/brander --style src/style.css
+npx --package @advantacode/brander advantacode-brander setup --style src/style.css
 ```
 
 This creates `brand.config.ts`, adds a `brand:generate` script, patches your stylesheet imports, and prepares the token output folder.
 
 During setup, Brander creates `brand.css` next to your main stylesheet, writes token/theme imports there, and adds a single `@import './brand.css';` to your main stylesheet.
-The generated `brand:generate` script uses `advantacode-brander generate` and includes any setup generation flags (`--out`, `--format`, `--theme`, `--prefix`) so repeat runs keep writing to the same target.
+Brander stores project paths like `project.outDir` and `project.styleFile` in `brand.config.*` so your `brand:generate` script can stay minimal.
 
 AdvantaCode Brander generates design tokens and framework adapters from a single brand configuration file. It allows applications, design systems, and design tools to share a consistent source of truth for colors and semantic tokens.
 
@@ -77,16 +79,17 @@ advantacode-brander --out src/tokens
 advantacode-brander --format css,tailwind,figma
 advantacode-brander --theme dark
 advantacode-brander --prefix ac
-advantacode-brander setup --out src/brander --style src/style.css
+advantacode-brander setup --style src/style.css
 advantacode-brander init --out src/brander
 ```
 
-Supported flags:
+Supported flags (CLI overrides `brand.config.*`):
 
-* `--out <dir>` writes generated files to a custom folder instead of `dist/brander`
+* `--out <dir>` writes generated files to a custom folder instead of `dist/brander` (or `project.outDir`)
 * `--format <list>` limits output to specific formats: `all`, `css`, `json`, `typescript` or `ts`, `scss`, `tailwind`, `bootstrap`, `figma`
-* `--theme <value>` limits theme CSS output to `light`, `dark`, or `both`
-* `--prefix <value>` applies a CSS variable prefix like `ac`, producing variables such as `--ac-primary`
+* `--theme <value>` limits theme CSS output to `light`, `dark`, or `both` (or `theme`)
+* `--prefix <value>` applies a CSS variable prefix like `ac`, producing variables such as `--ac-primary` (or `css.prefix`)
+* `--style <path>` refreshes `brand.css` and the main stylesheet import during normal generation (or `project.styleFile`)
 * `--version`, `-v` prints the installed package version
 * `--help`, `-h` prints the CLI help text
 
@@ -104,6 +107,12 @@ Example:
 ```ts
 export default {
   name: process.env.COMPANY_NAME || "My Company",
+  project: {
+    outDir: "src/assets/brand",
+    styleFile: "src/styles.css"
+  },
+
+  adapters: ["tailwind"],
   css: {
     prefix: process.env.CSS_PREFIX ?? ""
   },
@@ -117,6 +126,19 @@ export default {
     success: process.env.SUCCESS_COLOR || "green-500",
     warning: process.env.WARNING_COLOR || "yellow-500",
     danger: process.env.DANGER_COLOR || "red-500"
+  },
+
+  typography: {
+    fontSans: "Inter",
+    fontMono: "JetBrains Mono"
+  },
+
+  spacing: {
+    xs: "0.25rem",
+    sm: "0.5rem",
+    md: "1rem",
+    lg: "1.5rem",
+    xl: "2rem"
   }
 };
 ```
@@ -148,7 +170,7 @@ DANGER_COLOR=red-500
 
 ## Generated Outputs
 
-Running the CLI with no flags generates all formats into `dist/brander` and writes both light and dark theme CSS.
+If neither CLI `--format` nor `formats` / `adapters` are set in `brand.config.*`, running the CLI with no flags generates all formats into `dist/brander` and writes both light and dark theme CSS.
 
 ```text
 dist/
@@ -175,6 +197,8 @@ Example generated `tokens.css`:
 :root {
   --primary-500: oklch(0.65 0.2 45);
   --neutral-50: oklch(0.97 0.02 95);
+  --space-md: 1rem;
+  --font-sans: "Inter", sans-serif;
 }
 ```
 
@@ -280,6 +304,18 @@ text-danger
 border-secondary
 ```
 
+CommonJS Tailwind config:
+
+```js
+const brandPreset = require("./src/assets/brander/adapters/tailwind.preset");
+
+module.exports = {
+  presets: [brandPreset]
+};
+```
+
+This step should stay documented rather than auto-patched for now. Unlike stylesheet imports, Tailwind config shape varies across projects between CJS, ESM, TS, Vite plugins, and newer Tailwind entrypoints, so automatic mutation is riskier and easier to get wrong.
+
 ## Bootstrap / SCSS Frameworks
 
 Generated file:
@@ -359,6 +395,8 @@ AdvantaCode Brander is maintained under a closed governance model.
 
 Issues and feature requests are welcome, but pull requests may not be accepted.
 
+Maintainer release and publishing workflow documentation is in [docs/TECH_OVERVIEW.md](docs/TECH_OVERVIEW.md).
+
 See [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md) for details.
 
 ## Trademark Notice

package/dist/adapters/css.js

@@ -25,6 +25,25 @@ function renderPrimitiveTokens(tokenModel, variableOptions) {
             css += `  ${getVariableName(`${colorName}-${step}`, variableOptions)}: ${scale[step]};\n`;
         }
     }
+    if (tokenModel.spacing && Object.keys(tokenModel.spacing).length > 0) {
+        css += "\n";
+        for (const [spaceName, spaceToken] of Object.entries(tokenModel.spacing)) {
+            css += `  ${getVariableName(`space-${spaceName}`, variableOptions)}: ${spaceToken.value};\n`;
+        }
+    }
+    if (tokenModel.typography) {
+        const fontSans = tokenModel.typography.fontSans?.value;
+        const fontMono = tokenModel.typography.fontMono?.value;
+        if (fontSans || fontMono) {
+            css += "\n";
+        }
+        if (fontSans) {
+            css += `  ${getVariableName("font-sans", variableOptions)}: ${fontSans};\n`;
+        }
+        if (fontMono) {
+            css += `  ${getVariableName("font-mono", variableOptions)}: ${fontMono};\n`;
+        }
+    }
     css += "}\n";
     return css;
 }

package/dist/adapters/scss.js

@@ -38,6 +38,25 @@ function renderTokensScss(tokenModel, variableOptions) {
             scss += `${getSassVariableName(`${colorName}-${step}`, variableOptions)}: ${scale[step]};\n`;
         }
     }
+    if (tokenModel.spacing && Object.keys(tokenModel.spacing).length > 0) {
+        scss += "\n";
+        for (const [spaceName, spaceToken] of Object.entries(tokenModel.spacing)) {
+            scss += `${getSassVariableName(`space-${spaceName}`, variableOptions)}: ${spaceToken.value};\n`;
+        }
+    }
+    if (tokenModel.typography) {
+        const fontSans = tokenModel.typography.fontSans?.value;
+        const fontMono = tokenModel.typography.fontMono?.value;
+        if (fontSans || fontMono) {
+            scss += "\n";
+        }
+        if (fontSans) {
+            scss += `${getSassVariableName("font-sans", variableOptions)}: ${fontSans};\n`;
+        }
+        if (fontMono) {
+            scss += `${getSassVariableName("font-mono", variableOptions)}: ${fontMono};\n`;
+        }
+    }
     scss += "\n";
     for (const semanticTokenName of semanticTokenNames) {
         scss += `${getSassVariableName(semanticTokenName, variableOptions)}: ${tokenModel.color.semantic.light[semanticTokenName].value};\n`;

package/dist/adapters/tailwind.js

@@ -4,15 +4,36 @@ import { semanticTokenNames } from "../engine/semantics.js";
 import { getVariableReference } from "./variables.js";
 export function writeTailwindAdapter(outputDir, tokenModel, variableOptions) {
     const adaptersDir = path.join(outputDir, "adapters");
-    let preset = `export default {\n  theme: {\n    extend: {\n      colors: {\n`;
+    let preset = `export default {\n  theme: {\n    extend: {\n`;
     fs.mkdirSync(adaptersDir, { recursive: true });
+    preset += "      colors: {\n";
     for (const semanticTokenName of semanticTokenNames) {
         if (!tokenModel.color.semantic.light[semanticTokenName]) {
             continue;
         }
         preset += `        "${semanticTokenName}": "${getVariableReference(semanticTokenName, variableOptions)}",\n`;
     }
-    preset += "      }\n    }\n  }\n};\n";
+    preset += "      },\n";
+    if (tokenModel.spacing && Object.keys(tokenModel.spacing).length > 0) {
+        preset += "      spacing: {\n";
+        for (const spaceName of Object.keys(tokenModel.spacing)) {
+            preset += `        "${spaceName}": "${getVariableReference(`space-${spaceName}`, variableOptions)}",\n`;
+        }
+        preset += "      },\n";
+    }
+    const fontSans = tokenModel.typography?.fontSans?.value;
+    const fontMono = tokenModel.typography?.fontMono?.value;
+    if (fontSans || fontMono) {
+        preset += "      fontFamily: {\n";
+        if (fontSans) {
+            preset += `        "sans": ["${getVariableReference("font-sans", variableOptions)}"],\n`;
+        }
+        if (fontMono) {
+            preset += `        "mono": ["${getVariableReference("font-mono", variableOptions)}"],\n`;
+        }
+        preset += "      },\n";
+    }
+    preset += "    }\n  }\n};\n";
     fs.writeFileSync(path.join(adaptersDir, "tailwind.preset.ts"), preset);
     return ["adapters/tailwind.preset.ts"];
 }

package/dist/engine/themes.js

@@ -1,10 +1,10 @@
 import { generatePrimitivePalettes } from "./palette.js";
 import { buildThemeReferences, resolveThemeValues } from "./semantics.js";
-export function createTokenModel(baseColors) {
+export function createTokenModel(baseColors, extras) {
     const primitivePalettes = generatePrimitivePalettes(baseColors);
     const themeReferences = buildThemeReferences(primitivePalettes);
     const themeValues = resolveThemeValues(primitivePalettes, themeReferences);
-    return {
+    const tokenModel = {
         color: {
             primitive: primitivePalettes,
             semantic: {
@@ -13,6 +13,29 @@ export function createTokenModel(baseColors) {
             }
         }
     };
+    if (extras?.typography) {
+        const typography = {};
+        const fontSans = extras.typography.fontSans;
+        const fontMono = extras.typography.fontMono;
+        if (typeof fontSans === "string" && fontSans.trim()) {
+            typography.fontSans = { value: fontSans.trim() };
+        }
+        if (typeof fontMono === "string" && fontMono.trim()) {
+            typography.fontMono = { value: fontMono.trim() };
+        }
+        if (Object.keys(typography).length > 0) {
+            tokenModel.typography = typography;
+        }
+    }
+    if (extras?.spacing) {
+        const entries = Object.entries(extras.spacing).filter(([, value]) => typeof value === "string" && value.trim());
+        if (entries.length > 0) {
+            tokenModel.spacing = Object.fromEntries(entries
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, value]) => [key, { value: value.trim() }]));
+        }
+    }
+    return tokenModel;
 }
 function mapThemeTokens(references, values) {
     return Object.fromEntries(Object.entries(references).map(([tokenName, reference]) => [

package/dist/generate-tokens.js

@@ -11,6 +11,7 @@ import { writeTypeScriptArtifacts } from "./adapters/typescript.js";
 import { normalizeVariablePrefix } from "./adapters/variables.js";
 import { baseColorNames, resolveBaseColors } from "./engine/color-parser.js";
 import { createTokenModel } from "./engine/themes.js";
+import { syncStyleImports } from "./style-imports.js";
 export const supportedFormats = [
     "all",
     "css",
@@ -22,15 +23,18 @@ export const supportedFormats = [
     "figma"
 ];
 export async function generateTokens(options = {}) {
-    const defaultOutputDir = resolveDefaultOutputDir();
-    const outputDir = options.outputDir ? path.resolve(process.cwd(), options.outputDir) : defaultOutputDir;
-    const theme = options.theme ?? "both";
-    const formats = resolveFormats(options.formats);
     loadDotEnv({ path: path.resolve(process.cwd(), ".env"), quiet: true });
     const brandConfig = await loadBrandConfig();
+    const defaultOutputDir = resolveDefaultOutputDir();
+    const outputDir = resolveOutputDir(options.outputDir, brandConfig.project?.outDir, defaultOutputDir);
+    const theme = options.theme ?? brandConfig.theme ?? "both";
+    const formats = resolveFormats(options.formats ?? brandConfig.formats ?? resolveFormatsFromAdapters(brandConfig.adapters));
     const prefix = resolveCssPrefix(options.prefix, brandConfig.css?.prefix, process.env.CSS_PREFIX);
     const baseColors = resolveBaseColors(brandConfig.colors ?? {});
-    const tokenModel = createTokenModel(baseColors);
+    const tokenModel = createTokenModel(baseColors, {
+        typography: resolveTypographyConfig(brandConfig.typography),
+        spacing: brandConfig.spacing
+    });
     fs.mkdirSync(outputDir, { recursive: true });
     if (outputDir === defaultOutputDir) {
         removeLegacyGeneratedFiles();
@@ -69,6 +73,10 @@ export async function generateTokens(options = {}) {
         writtenArtifacts.push(...writeTypeScriptArtifacts(outputDir, tokenModel, metadata));
     }
     writtenArtifacts.push(...writeMetadataJson(outputDir, metadata));
+    const stylePath = options.stylePath ?? brandConfig.project?.styleFile;
+    if (stylePath && formats.has("css")) {
+        syncStyleImports(stylePath, outputDir, theme);
+    }
     console.log(`✔ AdvantaCode tokens generated in ${path.relative(process.cwd(), outputDir) || "."}!`);
 }
 async function loadBrandConfig() {
@@ -117,6 +125,67 @@ function parseBrandConfig(rawConfig, configPath) {
         }
         parsedConfig.name = config.name;
     }
+    if ("project" in config && config.project !== undefined) {
+        if (typeof config.project !== "object" || config.project === null || Array.isArray(config.project)) {
+            throw new Error(`Expected "project" in ${path.basename(configPath)} to be an object.`);
+        }
+        const projectConfig = config.project;
+        const parsedProjectConfig = {};
+        if ("outDir" in projectConfig && projectConfig.outDir !== undefined) {
+            if (typeof projectConfig.outDir !== "string") {
+                throw new Error(`Expected "project.outDir" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedProjectConfig.outDir = projectConfig.outDir;
+        }
+        if ("styleFile" in projectConfig && projectConfig.styleFile !== undefined) {
+            if (typeof projectConfig.styleFile !== "string") {
+                throw new Error(`Expected "project.styleFile" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedProjectConfig.styleFile = projectConfig.styleFile;
+        }
+        parsedConfig.project = parsedProjectConfig;
+    }
+    if ("adapters" in config && config.adapters !== undefined) {
+        if (!Array.isArray(config.adapters)) {
+            throw new Error(`Expected "adapters" in ${path.basename(configPath)} to be an array.`);
+        }
+        const parsedAdapters = [];
+        for (const adapter of config.adapters) {
+            if (typeof adapter !== "string") {
+                throw new Error(`Expected "adapters" entries in ${path.basename(configPath)} to be strings.`);
+            }
+            if (!["tailwind", "bootstrap", "figma"].includes(adapter)) {
+                throw new Error(`Unsupported adapter "${adapter}" in ${path.basename(configPath)}.`);
+            }
+            parsedAdapters.push(adapter);
+        }
+        parsedConfig.adapters = parsedAdapters;
+    }
+    if ("formats" in config && config.formats !== undefined) {
+        if (!Array.isArray(config.formats)) {
+            throw new Error(`Expected "formats" in ${path.basename(configPath)} to be an array.`);
+        }
+        const parsedFormats = [];
+        for (const format of config.formats) {
+            if (typeof format !== "string") {
+                throw new Error(`Expected "formats" entries in ${path.basename(configPath)} to be strings.`);
+            }
+            if (!supportedFormats.includes(format)) {
+                throw new Error(`Unknown format "${format}" in ${path.basename(configPath)}.`);
+            }
+            parsedFormats.push(format);
+        }
+        parsedConfig.formats = parsedFormats;
+    }
+    if ("theme" in config && config.theme !== undefined) {
+        if (typeof config.theme !== "string") {
+            throw new Error(`Expected "theme" in ${path.basename(configPath)} to be a string.`);
+        }
+        if (!["light", "dark", "both"].includes(config.theme)) {
+            throw new Error(`Invalid "theme" in ${path.basename(configPath)}. Use "light", "dark", or "both".`);
+        }
+        parsedConfig.theme = config.theme;
+    }
     if ("colors" in config && config.colors !== undefined) {
         if (typeof config.colors !== "object" || config.colors === null || Array.isArray(config.colors)) {
             throw new Error(`Expected "colors" in ${path.basename(configPath)} to be an object.`);
@@ -148,8 +217,92 @@ function parseBrandConfig(rawConfig, configPath) {
         }
         parsedConfig.css = parsedCssConfig;
     }
+    if ("typography" in config && config.typography !== undefined) {
+        if (typeof config.typography !== "object" || config.typography === null || Array.isArray(config.typography)) {
+            throw new Error(`Expected "typography" in ${path.basename(configPath)} to be an object.`);
+        }
+        const typographyConfig = config.typography;
+        const parsedTypographyConfig = {};
+        if ("fontSans" in typographyConfig && typographyConfig.fontSans !== undefined) {
+            if (typeof typographyConfig.fontSans !== "string") {
+                throw new Error(`Expected "typography.fontSans" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedTypographyConfig.fontSans = typographyConfig.fontSans;
+        }
+        if ("fontMono" in typographyConfig && typographyConfig.fontMono !== undefined) {
+            if (typeof typographyConfig.fontMono !== "string") {
+                throw new Error(`Expected "typography.fontMono" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedTypographyConfig.fontMono = typographyConfig.fontMono;
+        }
+        parsedConfig.typography = parsedTypographyConfig;
+    }
+    if ("spacing" in config && config.spacing !== undefined) {
+        if (typeof config.spacing !== "object" || config.spacing === null || Array.isArray(config.spacing)) {
+            throw new Error(`Expected "spacing" in ${path.basename(configPath)} to be an object.`);
+        }
+        const spacingEntries = Object.entries(config.spacing);
+        const parsedSpacing = {};
+        for (const [spaceName, spaceValue] of spacingEntries) {
+            if (!isSafeTokenKey(spaceName)) {
+                throw new Error(`Unsupported spacing token "${spaceName}" in ${path.basename(configPath)}. Use letters, numbers, ".", "_", or "-".`);
+            }
+            if (typeof spaceValue !== "string") {
+                throw new Error(`Expected spacing "${spaceName}" in ${path.basename(configPath)} to be a string.`);
+            }
+            parsedSpacing[spaceName] = spaceValue;
+        }
+        parsedConfig.spacing = parsedSpacing;
+    }
     return parsedConfig;
 }
+function isSafeTokenKey(value) {
+    return /^[A-Za-z0-9._-]+$/.test(value);
+}
+const genericFontFamilyKeywords = new Set([
+    "serif",
+    "sans-serif",
+    "monospace",
+    "cursive",
+    "fantasy",
+    "system-ui",
+    "ui-serif",
+    "ui-sans-serif",
+    "ui-monospace",
+    "ui-rounded",
+    "emoji",
+    "math",
+    "fangsong"
+]);
+function resolveTypographyConfig(config) {
+    if (!config) {
+        return undefined;
+    }
+    const resolved = {};
+    if (typeof config.fontSans === "string" && config.fontSans.trim()) {
+        resolved.fontSans = normalizeFontStack(config.fontSans, "sans-serif");
+    }
+    if (typeof config.fontMono === "string" && config.fontMono.trim()) {
+        resolved.fontMono = normalizeFontStack(config.fontMono, "monospace");
+    }
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+function normalizeFontStack(fontValue, fallback) {
+    const trimmed = fontValue.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    if (trimmed.includes(",")) {
+        return trimmed;
+    }
+    if (genericFontFamilyKeywords.has(trimmed)) {
+        return trimmed;
+    }
+    return `"${escapeCssString(trimmed)}", ${fallback}`;
+}
+function escapeCssString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
 function resolveFormats(formats) {
     const resolvedFormats = new Set();
     if (!formats || formats.length === 0 || formats.includes("all")) {
@@ -170,6 +323,16 @@ function resolveFormats(formats) {
     }
     return resolvedFormats;
 }
+function resolveFormatsFromAdapters(adapters) {
+    if (!adapters || adapters.length === 0) {
+        return undefined;
+    }
+    return ["css", ...adapters];
+}
+function resolveOutputDir(cliOutDir, configOutDir, defaultOutputDir) {
+    const resolvedOutDir = cliOutDir ?? configOutDir;
+    return resolvedOutDir ? path.resolve(process.cwd(), resolvedOutDir) : defaultOutputDir;
+}
 function removeLegacyGeneratedFiles() {
     const legacyFiles = [
         path.resolve(process.cwd(), "dist", "tokens.css"),

package/dist/index.js

@@ -14,7 +14,7 @@ export async function runCli(args) {
             return 0;
         }
         if (command === 'generate') {
-            await generateTokens(parseGenerateArgs(commandArgs));
+            await runGenerateCommand(parseGenerateArgs(commandArgs));
             return 0;
         }
         await setupProject(parseSetupArgs(command, commandArgs));
@@ -44,6 +44,9 @@ function resolveCommand(args) {
     }
     throw new Error(`Unknown command "${firstArg}". Use --help to see supported commands.`);
 }
+async function runGenerateCommand(options) {
+    await generateTokens(options);
+}
 function parseGenerateArgs(args) {
     const options = {};
     for (let index = 0; index < args.length; index += 1) {
@@ -74,6 +77,11 @@ function parseGenerateArgs(args) {
             index += 1;
             continue;
         }
+        if (arg === "--style") {
+            options.stylePath = getNextArgValue(arg, args, index);
+            index += 1;
+            continue;
+        }
         if (arg.startsWith("-")) {
             throw new Error(`Unknown option "${arg}". Use --help to see supported flags.`);
         }
@@ -161,11 +169,11 @@ Generation options:
   --theme <value>         Theme CSS output: light, dark, or both (default: both)
   --prefix <value>        CSS variable prefix. Use "" or omit for no prefix
 
-Examples:
-  advantacode-brander ${command}
-  advantacode-brander ${command} --out src/brander
-  advantacode-brander ${command} --style src/style.css
-  advantacode-brander ${command} --skip-imports --skip-generate
+Examples:
+  advantacode-brander ${command}
+  advantacode-brander ${command} --out src/brander
+  advantacode-brander ${command} --style src/style.css
+  advantacode-brander ${command} --skip-imports --skip-generate
 `;
     }
     return `AdvantaCode Brander
@@ -186,11 +194,13 @@ Options:
   --format <list>         Comma-separated formats: all, css, json, typescript|ts, scss, tailwind, bootstrap, figma
   --theme <value>         Theme CSS output: light, dark, or both (default: both)
   --prefix <value>        CSS variable prefix. Use "" or omit for no prefix
+  --style <path>          Main stylesheet file to patch with a brand.css import
 
-Examples:
-  advantacode-brander
-  advantacode-brander --out src/tokens
-  advantacode-brander setup --out src/brander --style src/style.css
-  advantacode-brander init --out resources/brander --skip-imports
+Examples:
+  advantacode-brander
+  advantacode-brander --out src/tokens
+  advantacode-brander --style src/style.css
+  advantacode-brander setup --style src/style.css
+  advantacode-brander init --out resources/brander --skip-imports
 `;
 }

package/dist/setup.js

@@ -1,32 +1,33 @@
 import fs from "fs";
 import path from "path";
 import { generateTokens } from "./generate-tokens.js";
+import { ensureStyleImports, resolveStylePath, syncStyleImports as syncStyleImportsImpl } from "./style-imports.js";
 const defaultSetupOutputDir = path.join("src", "brander");
-const brandStylesheetFileName = "brand.css";
-const defaultStyleCandidates = [
-    path.join("src", "style.css"),
-    path.join("src", "main.css"),
-    path.join("src", "index.css"),
-    path.join("src", "app.css"),
-    path.join("resources", "css", "app.css")
-];
 export async function setupProject(options) {
     const resolvedOutputDir = options.outputDir ?? defaultSetupOutputDir;
     const scriptName = options.scriptName ?? "brand:generate";
     const notes = [];
+    const resolvedStylePath = !options.skipImports ? resolveStylePath(options.stylePath) : undefined;
+    const configFormats = options.formats && options.formats.length > 0 ? options.formats : undefined;
     if (!options.skipConfig) {
-        const configResult = ensureBrandConfig();
+        const configResult = ensureBrandConfig({
+            outputDir: resolvedOutputDir,
+            styleFile: resolvedStylePath ? normalizeConfigPath(path.relative(process.cwd(), resolvedStylePath)) : undefined,
+            formats: configFormats,
+            adapters: !configFormats ? ["tailwind"] : undefined,
+            prefix: options.prefix,
+            theme: options.theme
+        });
         notes.push(configResult.message);
     }
     if (!options.skipScript) {
         const scriptResult = ensurePackageScript(scriptName, buildGenerateCommand({
-            ...options,
-            outputDir: resolvedOutputDir
+            ...options
         }));
         notes.push(scriptResult.message);
     }
     if (!options.skipImports) {
-        const styleResult = ensureStyleImports(options.stylePath, resolvedOutputDir);
+        const styleResult = ensureStyleImports(resolvedStylePath ? normalizeConfigPath(path.relative(process.cwd(), resolvedStylePath)) : undefined, resolvedOutputDir, options.theme ?? "both");
         notes.push(styleResult.message);
     }
     if (!options.skipGenerate) {
@@ -43,13 +44,8 @@ export async function setupProject(options) {
         console.log(`  - ${note}`);
     }
 }
-function ensureBrandConfig() {
-    const configPath = path.resolve(process.cwd(), "brand.config.js");
-    if (fs.existsSync(configPath)) {
-        return { message: "Kept existing brand.config.js." };
-    }
-    fs.writeFileSync(configPath, getDefaultBrandConfigTemplate());
-    return { message: "Created brand.config.js." };
+export function syncStyleImports(stylePath, outputDir) {
+    return syncStyleImportsImpl(stylePath, outputDir);
 }
 function ensurePackageScript(scriptName, command) {
     const packageJsonPath = path.resolve(process.cwd(), "package.json");
@@ -71,114 +67,79 @@ function ensurePackageScript(scriptName, command) {
     fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
     return { message: `Added "${scriptName}" script to package.json.` };
 }
-function ensureStyleImports(stylePath, outputDir) {
-    const resolvedStylePath = resolveStylePath(stylePath);
-    if (!resolvedStylePath) {
-        return {
-            message: "Skipped stylesheet imports because no stylesheet was found. Use --style <path> to target a file explicitly."
-        };
-    }
-    const brandStylesheetPath = path.join(path.dirname(resolvedStylePath), brandStylesheetFileName);
-    const brandStylesheetImports = [
-        buildImportLine(brandStylesheetPath, path.join(outputDir, "tokens.css")),
-        buildImportLine(brandStylesheetPath, path.join(outputDir, "themes", "light.css")),
-        buildImportLine(brandStylesheetPath, path.join(outputDir, "themes", "dark.css"))
-    ];
-    const brandStylesheetContents = `${brandStylesheetImports.join("\n")}\n`;
-    const hasBrandStylesheet = fs.existsSync(brandStylesheetPath);
-    const existingBrandStylesheet = hasBrandStylesheet ? fs.readFileSync(brandStylesheetPath, "utf8") : "";
-    if (existingBrandStylesheet !== brandStylesheetContents) {
-        fs.writeFileSync(brandStylesheetPath, brandStylesheetContents);
-    }
-    const styleFileContents = fs.readFileSync(resolvedStylePath, "utf8");
-    const legacyTokenImports = [
-        buildImportLine(resolvedStylePath, path.join(outputDir, "tokens.css")),
-        buildImportLine(resolvedStylePath, path.join(outputDir, "themes", "light.css")),
-        buildImportLine(resolvedStylePath, path.join(outputDir, "themes", "dark.css"))
-    ];
-    const brandImportLine = buildImportLine(resolvedStylePath, brandStylesheetPath);
-    const styleLineEnding = styleFileContents.includes("\r\n") ? "\r\n" : "\n";
-    const styleLines = styleFileContents.split(/\r?\n/);
-    const legacyImportCandidates = new Set();
-    for (const importLine of legacyTokenImports) {
-        legacyImportCandidates.add(importLine);
-        legacyImportCandidates.add(importLine.replace(/'/g, '"'));
-    }
-    let nextStyleLines = styleLines.filter((line) => !legacyImportCandidates.has(line.trim()));
-    const hasBrandImport = nextStyleLines.some((line) => line.trim() === brandImportLine || line.trim() === brandImportLine.replace(/'/g, '"'));
-    if (!hasBrandImport) {
-        nextStyleLines = [brandImportLine, ...nextStyleLines];
-    }
-    while (nextStyleLines[0] === "") {
-        nextStyleLines = nextStyleLines.slice(1);
-    }
-    const nextStyleContents = `${nextStyleLines.join(styleLineEnding)}${styleLineEnding}`;
-    if (nextStyleContents !== styleFileContents) {
-        fs.writeFileSync(resolvedStylePath, nextStyleContents);
-    }
-    const brandStylesheetStatus = hasBrandStylesheet ? "Updated" : "Created";
-    const mainStylesheetStatus = nextStyleContents === styleFileContents ? "Kept" : "Updated";
-    return {
-        message: `${brandStylesheetStatus} ${path.relative(process.cwd(), brandStylesheetPath)} and ${mainStylesheetStatus.toLowerCase()} ${path.relative(process.cwd(), resolvedStylePath)} to import it.`
-    };
+function normalizeConfigPath(value) {
+    return value.replace(/\\/g, "/");
 }
-function resolveStylePath(stylePath) {
-    if (stylePath) {
-        const candidatePath = path.resolve(process.cwd(), stylePath);
-        if (!fs.existsSync(candidatePath)) {
-            throw new Error(`Unable to find stylesheet "${stylePath}".`);
-        }
-        return candidatePath;
-    }
-    const existingCandidates = defaultStyleCandidates
-        .map((candidate) => path.resolve(process.cwd(), candidate))
-        .filter((candidatePath) => fs.existsSync(candidatePath));
-    if (existingCandidates.length === 1) {
-        return existingCandidates[0];
-    }
-    if (existingCandidates.length > 1) {
-        throw new Error(`Multiple stylesheet candidates were found: ${existingCandidates
-            .map((candidatePath) => path.relative(process.cwd(), candidatePath))
-            .join(", ")}. Use --style <path> to choose one.`);
-    }
-    return undefined;
+function buildGenerateCommand(options) {
+    void options;
+    return "advantacode-brander";
 }
-function buildImportLine(stylePath, targetPath) {
-    const relativeImportPath = path.relative(path.dirname(stylePath), path.resolve(process.cwd(), targetPath)).replace(/\\/g, "/");
-    const normalizedImportPath = relativeImportPath.startsWith(".") ? relativeImportPath : `./${relativeImportPath}`;
-    return `@import '${normalizedImportPath}';`;
+function ensureBrandConfig(options) {
+    const existingConfigPath = findExistingBrandConfigPath();
+    if (existingConfigPath) {
+        return { message: `Kept existing ${path.basename(existingConfigPath)}.` };
+    }
+    const configPath = path.resolve(process.cwd(), "brand.config.ts");
+    fs.writeFileSync(configPath, getDefaultBrandConfigTemplate(options));
+    return { message: `Created ${path.basename(configPath)}.` };
 }
-function buildGenerateCommand(options) {
-    const commandParts = ["advantacode-brander", "generate"];
-    const outputDir = options.outputDir ?? defaultSetupOutputDir;
-    commandParts.push("--out", outputDir);
-    if (options.formats && options.formats.length > 0) {
-        commandParts.push("--format", options.formats.join(","));
-    }
-    if (options.theme && options.theme !== "both") {
-        commandParts.push("--theme", options.theme);
-    }
-    if (options.prefix) {
-        commandParts.push("--prefix", options.prefix);
+function findExistingBrandConfigPath() {
+    const candidateFiles = [
+        "brand.config.ts",
+        "brand.config.mts",
+        "brand.config.cts",
+        "brand.config.js",
+        "brand.config.mjs",
+        "brand.config.cjs"
+    ];
+    for (const candidateFile of candidateFiles) {
+        const candidatePath = path.resolve(process.cwd(), candidateFile);
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
     }
-    return commandParts.join(" ");
+    return undefined;
 }
-function getDefaultBrandConfigTemplate() {
-    return `export default {
-  name: process.env.COMPANY_NAME || "My Company",
-  css: {
-    prefix: process.env.CSS_PREFIX ?? ""
-  },
-  colors: {
-    primary: process.env.PRIMARY_COLOR || "amber-500",
-    secondary: process.env.SECONDARY_COLOR || "zinc-700",
-    neutral: process.env.NEUTRAL_COLOR || process.env.SECONDARY_COLOR || "zinc-700",
-    accent: process.env.ACCENT_COLOR || "amber-400",
-    info: process.env.INFO_COLOR || "sky-500",
-    success: process.env.SUCCESS_COLOR || "green-500",
-    warning: process.env.WARNING_COLOR || "yellow-500",
-    danger: process.env.DANGER_COLOR || "red-500"
-  }
-};
+function getDefaultBrandConfigTemplate(options) {
+    const outDir = options?.outputDir ?? defaultSetupOutputDir;
+    const adapters = options?.adapters && options.adapters.length > 0 ? options.adapters : undefined;
+    const formats = options?.formats && options.formats.length > 0 ? options.formats : undefined;
+    const prefix = options?.prefix ? JSON.stringify(options.prefix) : "process.env.CSS_PREFIX ?? \"\"";
+    const themeLine = options?.theme && options.theme !== "both" ? `  theme: ${JSON.stringify(options.theme)},\n` : "";
+    const projectLines = [
+        `  project: {`,
+        `    outDir: ${JSON.stringify(outDir)},`,
+        ...(options?.styleFile ? [`    styleFile: ${JSON.stringify(options.styleFile)},`] : []),
+        `  },`
+    ].join("\n");
+    return `export default {
+  name: process.env.COMPANY_NAME || "My Company",
+${projectLines}
+
+${themeLine}${formats ? `  formats: ${JSON.stringify(formats)},\n` : ""}${adapters ? `  adapters: ${JSON.stringify(adapters)},\n` : ""}  css: {
+    prefix: ${prefix}
+  },
+  colors: {
+    primary: process.env.PRIMARY_COLOR || "amber-500",
+    secondary: process.env.SECONDARY_COLOR || "zinc-700",
+    neutral: process.env.NEUTRAL_COLOR || process.env.SECONDARY_COLOR || "zinc-700",
+    accent: process.env.ACCENT_COLOR || "amber-400",
+    info: process.env.INFO_COLOR || "sky-500",
+    success: process.env.SUCCESS_COLOR || "green-500",
+    warning: process.env.WARNING_COLOR || "yellow-500",
+    danger: process.env.DANGER_COLOR || "red-500"
+  },
+  typography: {
+    fontSans: "Inter",
+    fontMono: "JetBrains Mono"
+  },
+  spacing: {
+    xs: "0.25rem",
+    sm: "0.5rem",
+    md: "1rem",
+    lg: "1.5rem",
+    xl: "2rem"
+  }
+};
 `;
 }

package/dist/style-imports.js

@@ -0,0 +1,94 @@
+import fs from "fs";
+import path from "path";
+const brandStylesheetFileName = "brand.css";
+const defaultStyleCandidates = [
+    path.join("src", "style.css"),
+    path.join("src", "main.css"),
+    path.join("src", "index.css"),
+    path.join("src", "app.css"),
+    path.join("resources", "css", "app.css")
+];
+export function syncStyleImports(stylePath, outputDir, theme = "both") {
+    return ensureStyleImports(stylePath, outputDir, theme);
+}
+export function ensureStyleImports(stylePath, outputDir, theme = "both") {
+    const resolvedStylePath = resolveStylePath(stylePath);
+    if (!resolvedStylePath) {
+        return {
+            message: "Skipped stylesheet imports because no stylesheet was found. Use --style <path> to target a file explicitly."
+        };
+    }
+    const brandStylesheetPath = path.join(path.dirname(resolvedStylePath), brandStylesheetFileName);
+    const brandStylesheetImports = [buildImportLine(brandStylesheetPath, path.join(outputDir, "tokens.css"))];
+    if (theme === "light" || theme === "both") {
+        brandStylesheetImports.push(buildImportLine(brandStylesheetPath, path.join(outputDir, "themes", "light.css")));
+    }
+    if (theme === "dark" || theme === "both") {
+        brandStylesheetImports.push(buildImportLine(brandStylesheetPath, path.join(outputDir, "themes", "dark.css")));
+    }
+    const brandStylesheetContents = `${brandStylesheetImports.join("\n")}\n`;
+    const hasBrandStylesheet = fs.existsSync(brandStylesheetPath);
+    const existingBrandStylesheet = hasBrandStylesheet ? fs.readFileSync(brandStylesheetPath, "utf8") : "";
+    if (existingBrandStylesheet !== brandStylesheetContents) {
+        fs.writeFileSync(brandStylesheetPath, brandStylesheetContents);
+    }
+    const styleFileContents = fs.readFileSync(resolvedStylePath, "utf8");
+    const legacyTokenImports = [
+        buildImportLine(resolvedStylePath, path.join(outputDir, "tokens.css")),
+        buildImportLine(resolvedStylePath, path.join(outputDir, "themes", "light.css")),
+        buildImportLine(resolvedStylePath, path.join(outputDir, "themes", "dark.css"))
+    ];
+    const brandImportLine = buildImportLine(resolvedStylePath, brandStylesheetPath);
+    const styleLineEnding = styleFileContents.includes("\r\n") ? "\r\n" : "\n";
+    const styleLines = styleFileContents.split(/\r?\n/);
+    const legacyImportCandidates = new Set();
+    for (const importLine of legacyTokenImports) {
+        legacyImportCandidates.add(importLine);
+        legacyImportCandidates.add(importLine.replace(/'/g, '"'));
+    }
+    let nextStyleLines = styleLines.filter((line) => !legacyImportCandidates.has(line.trim()));
+    const hasBrandImport = nextStyleLines.some((line) => line.trim() === brandImportLine || line.trim() === brandImportLine.replace(/'/g, '"'));
+    if (!hasBrandImport) {
+        nextStyleLines = [brandImportLine, ...nextStyleLines];
+    }
+    while (nextStyleLines[0] === "") {
+        nextStyleLines = nextStyleLines.slice(1);
+    }
+    const nextStyleContents = `${nextStyleLines.join(styleLineEnding)}${styleLineEnding}`;
+    if (nextStyleContents !== styleFileContents) {
+        fs.writeFileSync(resolvedStylePath, nextStyleContents);
+    }
+    const brandStylesheetStatus = hasBrandStylesheet ? "Updated" : "Created";
+    const mainStylesheetStatus = nextStyleContents === styleFileContents ? "Kept" : "Updated";
+    return {
+        message: `${brandStylesheetStatus} ${path.relative(process.cwd(), brandStylesheetPath)} and ${mainStylesheetStatus.toLowerCase()} ${path.relative(process.cwd(), resolvedStylePath)} to import it.`
+    };
+}
+export function resolveStylePath(stylePath) {
+    if (stylePath) {
+        const candidatePath = path.resolve(process.cwd(), stylePath);
+        if (!fs.existsSync(candidatePath)) {
+            throw new Error(`Unable to find stylesheet "${stylePath}".`);
+        }
+        return candidatePath;
+    }
+    const existingCandidates = defaultStyleCandidates
+        .map((candidate) => path.resolve(process.cwd(), candidate))
+        .filter((candidatePath) => fs.existsSync(candidatePath));
+    if (existingCandidates.length === 1) {
+        return existingCandidates[0];
+    }
+    if (existingCandidates.length > 1) {
+        throw new Error(`Multiple stylesheet candidates were found: ${existingCandidates
+            .map((candidatePath) => path.relative(process.cwd(), candidatePath))
+            .join(", ")}. Use --style <path> to choose one.`);
+    }
+    return undefined;
+}
+function buildImportLine(stylePath, targetPath) {
+    const relativeImportPath = path
+        .relative(path.dirname(stylePath), path.resolve(process.cwd(), targetPath))
+        .replace(/\\/g, "/");
+    const normalizedImportPath = relativeImportPath.startsWith(".") ? relativeImportPath : `./${relativeImportPath}`;
+    return `@import '${normalizedImportPath}';`;
+}

package/docs/CONTRIBUTING.md

@@ -34,6 +34,10 @@ For internal architecture and technical details, see:
 
 [TECH_OVERVIEW.md](TECH_OVERVIEW.md)
 
+## Changelog
+
+User-facing changes should be recorded in `CHANGELOG.md` under the `[Unreleased]` section.
+
 ## Branding and Trademarks
 
 Use of the AdvantaCode name, logos, package names, domains, and other brand identifiers is governed by the trademark policy.

package/docs/TECH_OVERVIEW.md

@@ -308,12 +308,18 @@ Type definitions for Culori.
 brand.config.ts
 ```
 
-Defines the user-provided color inputs.
+Defines the user-provided project settings and design tokens.
+Also supports `project` output settings, optional `adapters` / `formats`, and optional `typography` (fonts) + `spacing` scales.
 
 Example:
 
 ```ts
 export default {
+  project: {
+    outDir: "src/assets/brand",
+    styleFile: "src/styles.css"
+  },
+  adapters: ["tailwind"],
   css: {
     prefix: ""
   },
@@ -321,6 +327,17 @@ export default {
     primary: "amber-500",
     secondary: "zinc-700",
     info: "sky-500"
+  },
+  typography: {
+    fontSans: "Inter",
+    fontMono: "JetBrains Mono"
+  },
+  spacing: {
+    xs: "0.25rem",
+    sm: "0.5rem",
+    md: "1rem",
+    lg: "1.5rem",
+    xl: "2rem"
   }
 };
 ```
@@ -452,9 +469,25 @@ Example:
 export default {
   name: "My Company",
 
+  project: {
+    outDir: "src/assets/brand",
+    styleFile: "src/styles.css"
+  },
+  adapters: ["tailwind"],
   colors: {
     primary: "amber-500",
     secondary: "zinc-700"
+  },
+  typography: {
+    fontSans: "Inter",
+    fontMono: "JetBrains Mono"
+  },
+  spacing: {
+    xs: "0.25rem",
+    sm: "0.5rem",
+    md: "1rem",
+    lg: "1.5rem",
+    xl: "2rem"
   }
 }
 ```
@@ -520,6 +553,27 @@ The current test coverage includes:
 
 ---
 
+# Release and Publishing
+
+For v1.0.0, keep release mechanics intentionally simple and rely on a short manual checklist.
+
+Preflight checks:
+
+```
+npm run release:check
+```
+
+Recommended flow:
+
+* update `CHANGELOG.md`
+* run `npm run release:check`
+* bump version with `npm version patch|minor|major`
+* cut the changelog section with `npm run changelog:cut` (uses the current `package.json` version)
+* publish with `npm publish`
+* push the commit + tag
+
+---
+
 # Run Token Generator
 
 For local repository development, you can execute the generator directly with:
@@ -554,6 +608,40 @@ Why `devDependency`:
 * Brander is a build-time code generation tool
 * the consuming app needs the generated token files at runtime, not the generator itself
 
+## Compatibility Test Matrix (v1.0.0)
+
+Keep v1.0.0 validation lean and focus on the integration points Brander actually owns:
+
+* config loading (`brand.config.ts` / `brand.config.js`)
+* writing outputs to `project.outDir`
+* CSS variable/theme correctness
+* `brand.css` wiring via `project.styleFile` (when applicable)
+* Tailwind preset adapter import + usage
+
+**Minimal matrix (recommended for v1):**
+
+1. Plain Vite + Tailwind (framework-agnostic baseline)
+2. Next.js + Tailwind (SSR + App Router + CSS import realities)
+3. Nuxt + Tailwind (Vue SSR ecosystem)
+4. One Vite SPA framework: Vue + Tailwind *or* React + Tailwind (framework independence)
+
+**Optional (adds credibility, not required for v1):**
+
+* Astro + Tailwind (marketing sites)
+* Laravel + Vite + Tailwind (monolith stack)
+* SvelteKit + Tailwind (non-React/Vue framework)
+
+**Notes:**
+
+* For Next.js/Nuxt/Astro you may prefer to skip `setup` import patching and wire `brand.css` manually in the framework’s global stylesheet entrypoint; still validate `generate` and token consumption.
+* Vite + Next.js covers the majority of real-world build tooling for Brander’s outputs.
+
+Automation (optional):
+
+* GitHub Actions workflow: `.github/workflows/consumer-matrix.yml`
+* Script used by the workflow: `scripts/consumer-smoke.sh`
+* The workflow packs the current commit (`npm pack`) and installs Brander from that tarball in each consumer project to avoid npm-registry drift.
+
 Build and pack Brander:
 
 ```
@@ -573,7 +661,7 @@ Add a script to the app:
 ```json
 {
   "scripts": {
-    "brand:generate": "advantacode-brander --out src/brander --format css,json,typescript --theme both"
+    "brand:generate": "advantacode-brander"
   }
 }
 ```
@@ -581,7 +669,7 @@ Add a script to the app:
 Or let Brander do that setup explicitly:
 
 ```
-npx --package @advantacode/brander advantacode-brander setup --out src/brander --style src/style.css
+npx --package @advantacode/brander advantacode-brander setup --style src/style.css
 ```
 
 That command:
@@ -709,24 +797,32 @@ The project compiles TypeScript using:
 
 # CLI Entry Point
 
-The source CLI entry point lives at:
+The source executable wrapper lives at:
 
 ```
-src/index.ts
+src/cli-wrapper.ts
 ```
 
-It uses this executable header during development:
+It uses this executable header:
 
 ```ts
-#!/usr/bin/env -S node --import tsx/esm
+#!/usr/bin/env node
+```
+
+CLI parsing and command behavior live in:
+
+```
+src/index.ts
 ```
 
-The published binary entry in `package.json` points to the compiled output:
+TypeScript config support is enabled at runtime by dynamically loading `tsx/esm` when a `brand.config.ts` is detected.
+
+The published binary entry in `package.json` points to the compiled wrapper:
 
 ```json
 {
   "bin": {
-    "advantacode-brander": "./dist/index.js"
+    "advantacode-brander": "./dist/cli-wrapper.js"
   }
 }
 ```

package/package.json

@@ -1,60 +1,64 @@
-{
-  "name": "@advantacode/brander",
-  "version": "0.2.0",
-  "description": "AdvantaCode Design System Brand Generator",
-  "type": "module",
-  "files": [
-    "dist/**/*.js",
-    "docs/*.md",
-    "README.md",
-    "LICENSE"
-  ],
-  "bin": {
-    "advantacode-brander": "./dist/cli-wrapper.js"
-  },
-  "scripts": {
-    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "npm run clean && tsc && chmod +x dist/cli-wrapper.js",
-    "cli": "node --import tsx/esm dist/cli-wrapper.js",
-    "lint": "eslint --max-warnings=0 src test",
-    "pretest": "npm run build",
-    "test": "node --import tsx/esm --test",
-    "release:check": "npm run lint && npm test && npm pack --dry-run",
-    "tokens": "tsx src/generate-tokens.ts",
-    "prepack": "npm run build",
-    "brand:generate": "advantacode-brander --out src/brander",
-    "brand:test": "node ./dist/cli-wrapper.js --out src/brander"
-  },
-  "license": "MIT",
-  "author": "Anthony Penn",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/advantacode/advantacode-brander.git"
-  },
-  "homepage": "https://github.com/advantacode/advantacode-brander#readme",
-  "bugs": {
-    "url": "https://github.com/advantacode/advantacode-brander/issues"
-  },
-  "keywords": [
-    "design-tokens",
-    "branding",
-    "oklch",
-    "tailwind",
-    "cli"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.3.3",
-    "@typescript-eslint/eslint-plugin": "^8.56.1",
-    "@typescript-eslint/parser": "^8.56.1",
-    "eslint": "^8.0.0",
-    "typescript": "^5.3.0"
-  },
-  "dependencies": {
-    "culori": "^4.0.2",
-    "dotenv": "^17.3.1",
-    "tsx": "^4.21.0"
-  }
-}
+{
+  "name": "@advantacode/brander",
+  "version": "0.3.0",
+  "description": "AdvantaCode Design System Brand Generator",
+  "type": "module",
+  "files": [
+    "dist/**/*.js",
+    "docs/*.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "advantacode-brander": "./dist/cli-wrapper.js"
+  },
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc && chmod +x dist/cli-wrapper.js",
+    "cli": "node --import tsx/esm dist/cli-wrapper.js",
+    "lint": "eslint --max-warnings=0 src test",
+    "pretest": "npm run build",
+    "test": "node --import tsx/esm --test",
+    "release:check": "npm run lint && npm test && npm pack --dry-run",
+    "tokens": "tsx src/generate-tokens.ts",
+    "prepack": "npm run build",
+    "changelog:cut": "node scripts/cut-changelog.mjs",
+    "brand:generate": "advantacode-brander",
+    "brand:test": "node ./dist/cli-wrapper.js"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Anthony Penn",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/advantacode/advantacode-brander.git"
+  },
+  "homepage": "https://github.com/advantacode/advantacode-brander#readme",
+  "bugs": {
+    "url": "https://github.com/advantacode/advantacode-brander/issues"
+  },
+  "keywords": [
+    "design-tokens",
+    "branding",
+    "oklch",
+    "tailwind",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "culori": "^4.0.2",
+    "dotenv": "^17.3.1",
+    "tsx": "^4.21.0"
+  }
+}