@replynodes/brand-kit 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.1
+
+- Migration target: publish the package as the public npm package `@replynodes/brand-kit`.
+- npm publication is the v0.1.1 release target and has not yet occurred.
+
+## 0.1.0
+
+- Initial public dependency-free CLI and deterministic six-file brand package.

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,21 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment include kindness, respect, constructive feedback, and accepting responsibility. Unacceptable behavior includes harassment, trolling, insults, discrimination, public or private harassment, and publishing others' private information without permission.
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing standards and may take fair corrective action. They will respond appropriately and fairly to reports.
+
+## Scope and Enforcement
+
+This Code applies in community spaces and when an individual officially represents the community. Report unacceptable behavior privately through the repository's GitHub Security Advisory form: https://github.com/replynodes/brand-kit/security/advisories/new. Do not post personal information or sensitive incident details in a public issue or pull request.
+
+## Attribution
+
+Adapted from Contributor Covenant version 2.1, available at https://www.contributor-covenant.org/version/2/1/code_of_conduct.html.

package/CONTRIBUTING.md

@@ -0,0 +1,15 @@
+# Contributing
+
+Contributions are welcome through GitHub issues and pull requests in `replynodes/brand-kit`. Open or find an issue first, explain the proposed change, and reference it from the PR. `main` is protected: changes require maintainer review and the required checks before merge. This project does not require a CLA.
+
+Keep the CLI dependency-free, deterministic, and within the public client contract. Before opening a PR, run the exact checks below:
+
+```sh
+node --check src/cli.mjs
+node --check bin/brand-kit.mjs
+node --check scripts/smoke.mjs
+npm run package-shape
+npm run smoke
+```
+
+The smoke command is the real black-box check against the public service. Do not add unit, white-box, per-function, or coverage-only tests; add a black-box smoke probe only when a behavior cannot be covered by the existing smoke. Do not add credentials, fixtures, telemetry, or backend changes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ReplyNodes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1 @@
+This repository is the MIT-licensed open-source client. The hosted ReplyNodes service is proprietary and separate, and its runtime endpoint is https://brand.replynodes.com/{bare-domain}. The client emits logo and backdrop references only; it does not download logo binaries.

package/README.md

@@ -0,0 +1,49 @@
+# brand-kit
+
+Turn a public domain into a deterministic, agent-ready brand context package in one command.
+
+## 10-second demo
+
+```sh
+npx @replynodes/brand-kit linear.app
+cat brand/brand.json
+```
+
+## Install and run
+
+```sh
+npm install -g @replynodes/brand-kit
+brand-kit example.com
+```
+
+The package is scoped as `@replynodes/brand-kit`, while the installed executable remains `brand-kit`.
+
+Pass exactly one bare domain. The client supports Node.js `>=20.19.0` on Linux x64/arm64, macOS x64/arm64, and Windows x64. CI verifies Node 20.x and 22.x; that does not claim every OS combination is tested.
+
+## Approved use cases
+
+- Agent-ready brand context: `npx @replynodes/brand-kit linear.app`
+- On-brand landing-page bootstrap: `npx @replynodes/brand-kit vercel.com`
+- CSS/token handoff: `npx @replynodes/brand-kit stripe.com`
+- Reusable reference package for slides/reports/email: `npx @replynodes/brand-kit github.com`
+- Portable design handoff/audit: `npx @replynodes/brand-kit notion.so`
+
+## Artifacts
+
+The command creates exactly six files in `./brand/`: `brand.json`, `colors.json`, `fonts.json`, `logos.json`, `tokens.css`, and `DESIGN.md`. Output is staged, then committed only after `./brand/` is exclusively reserved; existing destinations and files are never overwritten.
+
+## Limitations and non-goals
+
+This is a references-only client: it does not download or decode logos, fonts, or other binaries; scrape pages; follow redirects; sign up; accept API keys; send cookies; make per-capability requests; or provide video, Tailwind, MCP, or telemetry features. Optional source signals can be unavailable. The hosted service remains authoritative for public-address and SSRF checks.
+
+## How it works
+
+The CLI validates one normalized ASCII bare domain, makes one timed HTTPS GET to `https://brand.replynodes.com/{domain}`, normalizes the aggregate response, and writes stable JSON, CSS, and Markdown artifacts. The client uses only Node.js built-ins.
+
+## Attribution and service boundary
+
+The client in this repository is MIT-licensed. The hosted aggregate service at `brand.replynodes.com` is a proprietary ReplyNodes service with its own availability and terms; it is not bundled with, relicensed by, or made open source through this repository. See `NOTICE.md`.
+
+## Contribution and release notes
+
+See `CONTRIBUTING.md` for checks and contribution boundaries. CI runs smoke/contract checks on Node 20.x and 22.x. The v0.1.1 release target is publication of the scoped package to npm as a public package using trusted publishing with provenance; it has not yet been published.

package/SECURITY.md

@@ -0,0 +1,7 @@
+# Security
+
+Report suspected vulnerabilities privately through the GitHub Security Advisory form for this repository: https://github.com/replynodes/brand-kit/security/advisories/new. Do not open a public issue with exploit details.
+
+Include the affected version or commit, a concise impact description, reproduction steps or a minimal proof of concept, and any relevant logs with secrets removed. Avoid passwords, tokens, private keys, personal data, and other credentials. Never request credentials in a public issue or report, and do not send credentials in an advisory.
+
+The client makes one HTTPS GET, follows no redirects, sends no credentials or cookies, and writes only to a newly staged local `brand/` directory.

package/bin/brand-kit.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from '../src/cli.mjs';
+
+main().catch(() => {
+  process.stderr.write('brand-kit: the brand service could not complete the request; try again later\n');
+  process.exitCode = 3;
+});

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@replynodes/brand-kit",
+  "version": "0.1.1",
+  "description": "Generate a deterministic, agent-ready brand context package from a public brand aggregate.",
+  "type": "module",
+  "bin": { "brand-kit": "bin/brand-kit.mjs" },
+  "engines": { "node": ">=20.19.0" },
+  "files": ["bin", "src", "scripts", "README.md", "LICENSE", "NOTICE.md", "CONTRIBUTING.md", "SECURITY.md", "CODE_OF_CONDUCT.md", "CHANGELOG.md"],
+  "scripts": {
+    "smoke": "node scripts/smoke.mjs",
+    "package-shape": "npm pack --dry-run"
+  },
+  "license": "MIT"
+}

package/scripts/smoke.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const expectedFiles = ['DESIGN.md', 'brand.json', 'colors.json', 'fonts.json', 'logos.json', 'tokens.css'];
+const SMOKE_ERROR = 'brand-kit smoke: verification failed\n';
+
+async function runCli(root, cwd, domain) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(root, 'bin/brand-kit.mjs'), domain], { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '', stderr = '';
+    child.stdout.on('data', chunk => stdout += chunk);
+    child.stderr.on('data', chunk => stderr += chunk);
+    child.on('error', reject);
+    child.on('close', code => resolve({ code, stdout, stderr }));
+  });
+}
+
+async function assertExistingDestinationRejected(root, temp, setup, verify) {
+  await fs.rm(path.join(temp, 'brand'), { recursive: true, force: true });
+  await setup();
+  const result = await runCli(root, temp, 'linear.app');
+  assert.equal(result.code, 4);
+  assert.equal(result.stdout, '');
+  assert.equal(result.stderr, 'brand-kit: destination ./brand already exists; remove it or choose an empty working directory\n');
+  await verify();
+}
+
+async function run() {
+  const args = process.argv.slice(2);
+  if (args.length > 1) {
+    process.stderr.write('brand-kit smoke: expected at most one positional domain\n');
+    return 2;
+  }
+  const domain = args[0] ?? process.env.BRAND_KIT_SMOKE_DOMAIN ?? 'linear.app';
+  const temp = await fs.mkdtemp(path.join(os.tmpdir(), 'brand-kit-smoke-'));
+  const root = path.resolve(import.meta.dirname, '..');
+  try {
+    await assertExistingDestinationRejected(root, temp,
+      async () => { await fs.mkdir(path.join(temp, 'brand')); await fs.writeFile(path.join(temp, 'brand', 'keep.txt'), 'keep\n'); },
+      async () => assert.equal(await fs.readFile(path.join(temp, 'brand', 'keep.txt'), 'utf8'), 'keep\n'));
+    await assertExistingDestinationRejected(root, temp,
+      async () => { await fs.writeFile(path.join(temp, 'brand'), 'keep\n'); },
+      async () => assert.equal(await fs.readFile(path.join(temp, 'brand'), 'utf8'), 'keep\n'));
+    const danglingTarget = path.join(temp, 'missing-target');
+    await assertExistingDestinationRejected(root, temp,
+      async () => { await fs.symlink(danglingTarget, path.join(temp, 'brand')); },
+      async () => assert.equal((await fs.lstat(path.join(temp, 'brand'))).isSymbolicLink(), true));
+
+    await fs.rm(path.join(temp, 'brand'), { recursive: true, force: true });
+    const result = await runCli(root, temp, domain);
+    assert.equal(result.code, 0);
+    assert.equal(result.stdout, 'Brand kit written to ./brand/ (6 files)\n');
+    assert.equal(result.stderr, '');
+    const names = (await fs.readdir(path.join(temp, 'brand'))).sort();
+    assert.deepEqual(names, expectedFiles);
+    const jsonFiles = ['brand.json', 'colors.json', 'fonts.json', 'logos.json'];
+    const documents = Object.fromEntries(await Promise.all(jsonFiles.map(async file => [file, JSON.parse(await fs.readFile(path.join(temp, 'brand', file), 'utf8'))])));
+    assert.equal(documents['brand.json'].schema_version, '0.1');
+    assert.equal(typeof documents['brand.json'].domain, 'string');
+    assert.equal(typeof documents['brand.json'].url, 'string');
+    assert.equal(documents['colors.json'].schema_version, '0.1');
+    assert.ok(Array.isArray(documents['colors.json'].colors));
+    assert.equal(documents['fonts.json'].schema_version, '0.1');
+    assert.ok(Array.isArray(documents['fonts.json'].fonts));
+    assert.equal(documents['logos.json'].schema_version, '0.1');
+    assert.ok(Array.isArray(documents['logos.json'].logos));
+    for (const file of names) assert.ok((await fs.stat(path.join(temp, 'brand', file))).isFile());
+    assert.equal((await fs.readdir(path.join(temp, 'brand'))).filter(name => /\.(png|jpe?g|gif|webp|woff2?|ttf|otf)$/i.test(name)).length, 0);
+    console.log(`Smoke passed for ${domain} (Node ${process.versions.node}; this is a live endpoint check, not an all-OS matrix claim).`);
+    return 0;
+  } finally {
+    await fs.rm(temp, { recursive: true, force: true });
+  }
+}
+
+try {
+  process.exitCode = await run();
+} catch {
+  process.stderr.write(SMOKE_ERROR);
+  process.exitCode = 1;
+}

package/src/cli.mjs

@@ -0,0 +1,235 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const ARG_ERROR = 'brand-kit: provide exactly one bare domain, for example example.com';
+const SERVICE_ERROR = 'brand-kit: the brand service could not complete the request; try again later';
+const DEST_ERROR = 'brand-kit: destination ./brand already exists; remove it or choose an empty working directory';
+const endpoint = 'https://brand.replynodes.com/';
+
+const isString = value => typeof value === 'string';
+const scalar = value => isString(value) ? value : null;
+const cmpText = (a, b) => {
+  const aa = [...String(a)], bb = [...String(b)];
+  for (let i = 0; i < Math.min(aa.length, bb.length); i++) {
+    const c = aa[i].codePointAt(0) - bb[i].codePointAt(0);
+    if (c) return c;
+  }
+  return aa.length - bb.length;
+};
+const json = value => JSON.stringify(value, null, 2) + '\n';
+
+function canonical(value) {
+  if (Array.isArray(value)) {
+    const values = value.map(canonical);
+    const seen = new Set();
+    return values.filter(item => {
+      const key = JSON.stringify(item);
+      if (seen.has(key)) return false;
+      seen.add(key); return true;
+    }).sort((a, b) => Buffer.from(JSON.stringify(a)).compare(Buffer.from(JSON.stringify(b))));
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.keys(value).sort(cmpText).map(key => [key, canonical(value[key])]));
+  }
+  return value;
+}
+
+function normalizeDomain(raw) {
+  if (!isString(raw)) return null;
+  let value = raw.trim();
+  if (!value || /[^\x00-\x7f]/.test(value) || /[\x00-\x20\x7f]/.test(value)) return null;
+  value = value.toLowerCase();
+  if (value.startsWith('www.')) value = value.slice(4);
+  if (value.endsWith('.')) value = value.slice(0, -1);
+  if (!value || value.includes(':') || value.includes('/') || value.includes('\\') || value.includes('@') || value.includes('?') || value.includes('#')) return null;
+  if (/^(?:\d{1,3}\.){3}\d{1,3}$/.test(value) || /^\[[^\]]+\]$/.test(value)) return null;
+  if (value.length > 253) return null;
+  const labels = value.split('.');
+  if (labels.length < 2 || labels.some(label => !label || label.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label))) return null;
+  return value;
+}
+
+function list(value) { return Array.isArray(value) ? value : []; }
+
+function normalizeSocial(value) {
+  return [...new Set(list(value).filter(isString))].sort(cmpText);
+}
+
+function normalizeStyleguide(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const result = {};
+  for (const key of ['domain', 'url', 'status']) if (key in value) result[key] = scalar(value[key]);
+  for (const key of ['mode', 'colors', 'typography', 'buttons', 'card', 'spacing', 'shadows', 'radii']) {
+    if (key in value) result[key] = value[key];
+  }
+  return Object.keys(result).length ? canonical(result) : null;
+}
+
+function normalizeColors(value) {
+  const items = list(value).map(item => {
+    const source = item && typeof item === 'object' && !Array.isArray(item) ? item : {};
+    return { hex: scalar(source.hex), usage: scalar(source.usage), count: Number.isInteger(source.count) ? source.count : null };
+  });
+  const key = item => [item.hex === null ? 0 : 1, item.hex === null ? '' : item.hex.toLowerCase(), item.hex ?? '', item.usage === null ? 0 : 1, item.usage === null ? '' : item.usage.toLowerCase(), item.usage ?? '', item.count === null ? 1 : 0, item.count === null ? 0 : -item.count, JSON.stringify(item)];
+  items.sort((a, b) => { const ka = key(a), kb = key(b); for (let i = 0; i < ka.length; i++) { const av = ka[i], bv = kb[i]; const c = typeof av === 'number' && typeof bv === 'number' ? av - bv : cmpText(String(av), String(bv)); if (c) return c; } return 0; });
+  return items.filter((item, index) => index === 0 || JSON.stringify(item) !== JSON.stringify(items[index - 1]));
+}
+
+function normalizeFonts(value) {
+  const fonts = [...new Set(list(value).filter(isString))];
+  return fonts.sort((a, b) => cmpText(a.toLocaleLowerCase('en-US'), b.toLocaleLowerCase('en-US')) || cmpText(a, b));
+}
+
+function sourceValue(value) { return isString(value) ? value : null; }
+function normalizeAssetList(value) {
+  const assets = list(value).map(item => {
+    const source = item && typeof item === 'object' && !Array.isArray(item) ? item : {};
+    return { url: sourceValue(source.url), kind: sourceValue(source.kind) };
+  });
+  const compare = (a, b) => {
+    const fields = [['url', true], ['kind', true]];
+    for (const [field, nullFirst] of fields) {
+      const av = a[field], bv = b[field];
+      if (av === null || bv === null) { if (av === bv) continue; return av === null === nullFirst ? -1 : 1; }
+      const c = cmpText(String(av), String(bv)); if (c) return c;
+    }
+    return cmpText(JSON.stringify(a), JSON.stringify(b));
+  };
+  assets.sort(compare);
+  return assets.filter((item, i) => i === 0 || JSON.stringify(item) !== JSON.stringify(assets[i - 1]));
+}
+
+function normalizeResponse(data, domain) {
+  if (!data || typeof data !== 'object' || Array.isArray(data) || !isString(data.domain) || !isString(data.url) || !data.meta || typeof data.meta !== 'object' || Array.isArray(data.meta)) return null;
+  const stableMeta = {};
+  for (const key of ['domain', 'cache_ttl_seconds', 'source', 'docs']) if (key in data.meta && key !== 'cached' && key !== 'fetched_at') stableMeta[key] = canonical(data.meta[key]);
+  const colors = normalizeColors(data.colors);
+  const fonts = normalizeFonts(data.fonts);
+  const assets = normalizeAssetList(data.logos);
+  const backdrops = normalizeAssetList(data.backdrops);
+  return {
+    brand: { schema_version: '0.1', domain: data.domain, url: data.url, name: scalar(data.name), description: scalar(data.description), favicon: scalar(data.favicon), og_image: scalar(data.og_image), social_links: normalizeSocial(data.social_links), styleguide: normalizeStyleguide(data.styleguide), meta: stableMeta },
+    colors: { schema_version: '0.1', colors },
+    fonts: { schema_version: '0.1', fonts },
+    logos: { schema_version: '0.1', primary_logo: sourceValue(data.primary_logo), logos: assets, backdrops },
+    domain,
+    sourceUrl: data.url
+  };
+}
+
+function cssString(value) {
+  return '"' + [...value].map(char => { const code = char.codePointAt(0); if (char === '\\') return '\\\\'; if (char === '"') return '\\"'; if (code < 0x20 || code === 0x7f) return `\\${code.toString(16)} `; return char; }).join('') + '"';
+}
+
+function tokens(data) {
+  const lines = ['/* Brand Kit tokens v0.1: generated from available source signals. */'];
+  const vars = [];
+  const seenColors = new Set();
+  let colorIndex = 0;
+  for (const item of data.colors.colors) {
+    if (item.hex === null) continue;
+    const colorKey = item.hex.toLowerCase();
+    if (seenColors.has(colorKey)) continue;
+    seenColors.add(colorKey);
+    colorIndex += 1;
+    vars.push(`  --brand-color-${colorIndex}: ${/^#[0-9a-fA-F]{3,8}$/.test(item.hex) ? item.hex : cssString(item.hex)};`);
+  }
+  for (let i = 0; i < data.fonts.fonts.length; i++) vars.push(`  --brand-font-${i + 1}: ${cssString(data.fonts.fonts[i])};`);
+  if (!vars.length) lines.push('/* No color or font tokens were available. */');
+  lines.push(':root {', ...vars, '}');
+  return lines.join('\n') + '\n';
+}
+
+function markdown(data) {
+  const b = data.brand, style = b.styleguide;
+  const lines = [`# Design notes for ${data.domain}`, '', '## Summary', '', b.description ?? 'Unavailable.', '', '## Colors', ''];
+  if (data.colors.colors.length) for (const item of data.colors.colors) lines.push(`- ${item.hex ?? 'Unavailable'} — ${item.usage ?? 'usage unavailable'}${item.count === null ? '' : ` (${item.count})`}`); else lines.push('- Unavailable.');
+  lines.push('', '## Typography', '');
+  if (data.fonts.fonts.length) for (const font of data.fonts.fonts) lines.push(`- ${font}`); else lines.push('- Unavailable.');
+  lines.push('', '## Logos and assets', '', `- Primary logo: ${data.logos.primary_logo ?? 'Unavailable.'}`);
+  if (data.logos.logos.length) for (const item of data.logos.logos) lines.push(`- Logo: ${item.url ?? 'Unavailable'} (${item.kind ?? 'kind unavailable'})`);
+  if (data.logos.backdrops.length) for (const item of data.logos.backdrops) lines.push(`- Backdrop: ${item.url ?? 'Unavailable'} (${item.kind ?? 'kind unavailable'})`);
+  if (!data.logos.logos.length && !data.logos.backdrops.length) lines.push('- Additional assets unavailable.');
+  lines.push('', '## Styleguide', '', style ? `- Status: ${style.status ?? 'available'}` : '- Unavailable or omitted by the source.', '');
+  if (style) for (const key of ['mode', 'colors', 'typography', 'buttons', 'card', 'spacing', 'shadows', 'radii']) if (key in style) lines.push(`- ${key}: ${JSON.stringify(style[key])}`);
+  lines.push('', '## Provenance and limitations', '', `- Aggregate URL: ${b.url}`, '- Source URLs and assets are references only; no logo binary, font, or other asset was fetched.', '- The package reflects available public source signals. Optional fields may be unavailable; no recommendations or volatile metadata are included.', '');
+  return lines.join('\n');
+}
+
+async function request(domain) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 15000);
+  try {
+    const response = await fetch(endpoint + encodeURIComponent(domain), { method: 'GET', signal: controller.signal, redirect: 'error' });
+    if (!response.ok) throw new Error('status');
+    const data = await response.json();
+    return normalizeResponse(data, domain);
+  } finally { clearTimeout(timer); }
+}
+
+async function exists(file) { try { await fs.lstat(file); return true; } catch { return false; } }
+
+function sameIdentity(actual, expected) {
+  return actual.dev === expected.dev && actual.ino === expected.ino;
+}
+
+async function removeOwnedDestination(destination, destinationIdentity, files) {
+  for (const [file, identity] of files.reverse()) {
+    try {
+      const current = await fs.lstat(file);
+      if (sameIdentity(current, identity)) await fs.unlink(file);
+    } catch {}
+  }
+  try {
+    const current = await fs.lstat(destination);
+    if (sameIdentity(current, destinationIdentity)) await fs.rmdir(destination);
+  } catch {}
+}
+
+export async function main() {
+  const args = process.argv.slice(2);
+  if (args.length !== 1) { process.stderr.write(ARG_ERROR + '\n'); process.exitCode = 2; return; }
+  const domain = normalizeDomain(args[0]);
+  if (!domain) { process.stderr.write(ARG_ERROR + '\n'); process.exitCode = 2; return; }
+  const destination = path.resolve('brand');
+  if (await exists(destination)) { process.stderr.write(DEST_ERROR + '\n'); process.exitCode = 4; return; }
+  let data;
+  try { data = await request(domain); if (!data) throw new Error('malformed'); } catch { process.stderr.write(SERVICE_ERROR + '\n'); process.exitCode = 3; return; }
+  const stage = await fs.mkdtemp(path.resolve('.brand-stage-'));
+  let reserved = false;
+  let destinationIdentity;
+  let destinationConflict = false;
+  const committed = [];
+  try {
+    const files = { 'brand.json': json(data.brand), 'colors.json': json(data.colors), 'fonts.json': json(data.fonts), 'logos.json': json(data.logos), 'tokens.css': tokens(data), 'DESIGN.md': markdown(data) };
+    for (const [name, content] of Object.entries(files)) await fs.writeFile(path.join(stage, name), content, 'utf8');
+    try {
+      await fs.mkdir(destination);
+      reserved = true;
+      destinationIdentity = await fs.lstat(destination);
+    } catch (error) {
+      if (error?.code === 'EEXIST') {
+        await fs.rm(stage, { recursive: true, force: true }).catch(() => {});
+        process.stderr.write(DEST_ERROR + '\n'); process.exitCode = 4; return;
+      }
+      throw error;
+    }
+    for (const name of Object.keys(files)) {
+      const target = path.join(destination, name);
+      try {
+        await fs.copyFile(path.join(stage, name), target, fs.constants.COPYFILE_EXCL);
+      } catch (error) {
+        if (error?.code === 'EEXIST') destinationConflict = true;
+        throw error;
+      }
+      committed.push([target, await fs.lstat(target)]);
+    }
+  } catch {
+    await fs.rm(stage, { recursive: true, force: true }).catch(() => {});
+    if (reserved) await removeOwnedDestination(destination, destinationIdentity, committed);
+    process.stderr.write(destinationConflict ? DEST_ERROR + '\n' : SERVICE_ERROR + '\n');
+    process.exitCode = destinationConflict ? 4 : 3; return;
+  }
+  await fs.rm(stage, { recursive: true, force: true });
+  process.stdout.write('Brand kit written to ./brand/ (6 files)\n');
+}