makeables 0.10.0 → 0.11.0

package/dist/chunk-ZZA6CR6X.js

@@ -0,0 +1,700 @@
+import {
+  readKit
+} from "./chunk-6RBOBRL4.js";
+import {
+  InputError,
+  readSubmission,
+  submitDesign
+} from "./chunk-YB2YJCBS.js";
+import {
+  assemblePackage,
+  brandDocumentSchema,
+  brandPackageDocumentSchema,
+  jsonBytes
+} from "./chunk-DLTVENEP.js";
+
+// src/brand.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, extname, join, relative, resolve } from "path";
+import { createCanvas, loadImage } from "@napi-rs/canvas";
+import sharp from "sharp";
+var imageFile = /\.(svg|png|webp|jpe?g)$/i;
+var REF_IMAGE_LIMIT = 2e6;
+async function readBrand(file) {
+  return brandDocumentSchema.parse(JSON.parse(await readFile(resolve(file), "utf8")));
+}
+async function writeBrand(file, brand) {
+  await writeFile(resolve(file), `${JSON.stringify(brandDocumentSchema.parse(brand), null, 2)}
+`);
+}
+function slugify(value) {
+  return value.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "brand";
+}
+function newBrand(name, slug = slugify(name)) {
+  return brandDocumentSchema.parse({
+    format: "makeables-brand",
+    version: 1,
+    slug,
+    name,
+    description: `${name} on Makeables.`
+  });
+}
+async function addBrandKit(file, ref, id, family) {
+  const brand = await readBrand(file);
+  const path = resolve(ref);
+  const pkg = await readSubmission(path);
+  if (pkg.manifest.product !== "kit") throw new InputError("Add a kit document or kit package.");
+  const families = family && !brand.families.some((entry) => entry.id === family);
+  return brandDocumentSchema.parse({
+    ...brand,
+    families: families ? [...brand.families, { id: family, name: pkg.manifest.title.slice(0, 40) }] : brand.families,
+    kits: [
+      ...brand.kits.filter((kit) => kit.id !== id),
+      { id, ...family ? { family } : {}, file: relative(dirname(resolve(file)), path) }
+    ]
+  });
+}
+async function artTone(bytes) {
+  const { data } = await sharp(bytes, { density: 72 }).resize(32, 32, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  let sum = 0, count = 0;
+  for (let i = 0; i < data.length; i += 4)
+    if (data[i + 3] > 128) {
+      sum += 0.2126 * data[i] + 0.7152 * data[i + 1] + 0.0722 * data[i + 2];
+      count++;
+    }
+  return count && sum / count > 150 ? "light" : "dark";
+}
+async function addBrandLogo(file, ref, id, name = id) {
+  const brand = await readBrand(file);
+  const bytes = await readFile(resolve(ref));
+  const info = await imageInfo(bytes);
+  if (!info) throw new InputError("Choose an SVG, PNG, WebP or JPEG logo.");
+  const svg = info.format === "svg";
+  const base = dirname(resolve(file));
+  await mkdir(join(base, "refs"), { recursive: true });
+  const path = join("refs", `${id}.${svg ? "svg" : "png"}`);
+  await writeFile(join(base, path), svg ? bytes : await fitImage(bytes));
+  return brandDocumentSchema.parse({
+    ...brand,
+    logos: [
+      ...brand.logos.filter((logo) => logo.id !== id),
+      { id, name, file: path, tone: await artTone(bytes) }
+    ]
+  });
+}
+async function fitImage(bytes, maxSide = 1600) {
+  let side = maxSide;
+  for (; ; ) {
+    const out = await sharp(bytes).resize({ width: side, height: side, fit: "inside", withoutEnlargement: true }).png().toBuffer();
+    if (out.length <= REF_IMAGE_LIMIT || side <= 400) return new Uint8Array(out);
+    side = Math.round(side * 0.8);
+  }
+}
+function hexOf(r, g, b) {
+  return `#${[r, g, b].map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
+}
+function luminance(hex) {
+  const [r, g, b] = [1, 3, 5].map((i) => Number.parseInt(hex.slice(i, i + 2), 16) / 255);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+async function paletteOf(bytes) {
+  const { data } = await sharp(bytes).resize(64, 64, { fit: "inside" }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const buckets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < data.length; i += 3) {
+    const key = [data[i] >> 5, data[i + 1] >> 5, data[i + 2] >> 5].join();
+    const entry = buckets.get(key) ?? { n: 0, r: 0, g: 0, b: 0 };
+    entry.n++;
+    entry.r += data[i];
+    entry.g += data[i + 1];
+    entry.b += data[i + 2];
+    buckets.set(key, entry);
+  }
+  const colors = [...buckets.values()].sort((a, b) => b.n - a.n).map((c) => hexOf(c.r / c.n, c.g / c.n, c.b / c.n));
+  const chroma = (hex) => {
+    const [r, g, b] = [1, 3, 5].map((i) => Number.parseInt(hex.slice(i, i + 2), 16));
+    return Math.max(r, g, b) - Math.min(r, g, b);
+  };
+  const dark = colors.find((c) => luminance(c) < 0.2) ?? "#141414";
+  const light = colors.find((c) => luminance(c) > 0.8) ?? "#f4f1eb";
+  const accents = colors.filter((c) => chroma(c) > 70);
+  const base = luminance(colors[0] ?? light) < 0.5 ? { paper: dark, ink: light } : { paper: light, ink: dark };
+  return {
+    ...base,
+    accent: accents[0] ?? "#ff5a1f",
+    ...accents[1] ? { accent2: accents[1] } : {}
+  };
+}
+function attribute(tag, name) {
+  return tag.match(new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)')`, "i"))?.slice(2).find(Boolean);
+}
+function decode(text) {
+  return text.replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;|&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+function pageFacts(html, base) {
+  const facts = { icons: [], logos: [] };
+  const absolute = (value) => {
+    if (!value) return void 0;
+    try {
+      const url = new URL(decode(value), base);
+      return url.protocol === "https:" || url.protocol === "http:" ? url.href : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  for (const tag of html.match(/<meta\b[^>]*>/gi) ?? []) {
+    const key = (attribute(tag, "property") ?? attribute(tag, "name") ?? "").toLowerCase();
+    const content = attribute(tag, "content");
+    if (!content) continue;
+    if (key === "og:title" || key === "twitter:title" && !facts.title)
+      facts.title = decode(content);
+    if (key === "og:description" || key === "description" && !facts.description)
+      facts.description = decode(content);
+    if (key === "og:image" || key === "twitter:image" && !facts.image)
+      facts.image = absolute(content);
+  }
+  if (!facts.title)
+    facts.title = decode(html.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1]?.trim() ?? "");
+  for (const tag of html.match(/<link\b[^>]*>/gi) ?? []) {
+    const rel = (attribute(tag, "rel") ?? "").toLowerCase();
+    const href = absolute(attribute(tag, "href"));
+    if (href && /icon|apple-touch-icon|mask-icon/.test(rel)) facts.icons.push(href);
+  }
+  for (const tag of html.match(/<img\b[^>]*>/gi) ?? []) {
+    const text = `${attribute(tag, "alt") ?? ""} ${attribute(tag, "class") ?? ""} ${attribute(tag, "src") ?? ""}`;
+    const src = absolute(attribute(tag, "src"));
+    if (src && /logo|wordmark|lockup|brand/i.test(text)) facts.logos.push(src);
+  }
+  for (const block of html.match(/<script[^>]+application\/ld\+json[^>]*>[\s\S]*?<\/script>/gi) ?? []) {
+    try {
+      const value = JSON.parse(block.replace(/^<script[^>]*>|<\/script>$/gi, ""));
+      for (const entry of [
+        value,
+        ...Array.isArray(value["@graph"]) ? value["@graph"] : []
+      ].flat()) {
+        if (!entry || typeof entry !== "object" || !/Event/.test(String(entry["@type"]))) continue;
+        facts.event ??= entry.name;
+        facts.date ??= entry.startDate;
+        const location = Array.isArray(entry.location) ? entry.location[0] : entry.location;
+        facts.place ??= location?.name ?? location?.address?.addressLocality;
+        const image = absolute(Array.isArray(entry.image) ? entry.image[0] : entry.image);
+        if (image) facts.image = image;
+      }
+    } catch {
+    }
+  }
+  facts.icons = [...new Set(facts.icons)];
+  facts.logos = [...new Set(facts.logos)];
+  return facts;
+}
+function renderedHtml(url) {
+  const run = (args) => spawnSync("agent-browser", args, { encoding: "utf8", shell: false, timeout: 6e4 });
+  if (run(["--version"]).status !== 0) return null;
+  if (run(["open", url]).status !== 0) return null;
+  run(["wait", "2000"]);
+  const result = run(["eval", "document.documentElement.outerHTML"]);
+  if (result.status !== 0) return null;
+  try {
+    const value = JSON.parse(result.stdout.trim());
+    return typeof value === "string" ? value : null;
+  } catch {
+    return result.stdout || null;
+  }
+}
+async function fetchBytes(url, limit = 12e6) {
+  const response = await fetch(url, {
+    headers: { "User-Agent": "Mozilla/5.0 (compatible; Makeables/1.0; +https://makeables.dev)" },
+    redirect: "follow",
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (!response.ok) throw new InputError(`Could not fetch ${url}: HTTP ${response.status}.`);
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (bytes.length > limit) throw new InputError(`${url} exceeds ${limit / 1e6} MB.`);
+  return { bytes, type: response.headers.get("content-type") ?? "" };
+}
+async function imageInfo(bytes) {
+  try {
+    const meta = await sharp(bytes).metadata();
+    return meta.width && meta.height ? meta : null;
+  } catch {
+    return null;
+  }
+}
+async function refsProof(brand, files, facts) {
+  const width = 1600;
+  const cell = 340;
+  const columns = 4;
+  const rows = Math.max(1, Math.ceil(files.length / columns));
+  const height = 260 + rows * (cell + 60) + 180;
+  const canvas = createCanvas(width, height);
+  const context = canvas.getContext("2d");
+  context.fillStyle = "#f4f1eb";
+  context.fillRect(0, 0, width, height);
+  context.fillStyle = "#141414";
+  context.font = "bold 52px sans-serif";
+  context.fillText(`${brand.name} \xB7 brand refs`, 60, 90, width - 120);
+  context.font = "22px sans-serif";
+  facts.slice(0, 3).forEach((line, i) => {
+    context.fillText(line, 60, 135 + i * 30, width - 120);
+  });
+  for (const [index, file] of files.entries()) {
+    const x = 60 + index % columns * (cell + 30);
+    const y = 240 + Math.floor(index / columns) * (cell + 60);
+    try {
+      const png = await sharp(await readFile(file.path)).png().toBuffer();
+      context.fillStyle = await artTone(png) === "light" ? "#2a2a2a" : "#e6e2d9";
+      context.fillRect(x, y, cell, cell);
+      const image = await loadImage(png);
+      const scale = Math.min((cell - 40) / image.width, (cell - 40) / image.height, 4);
+      const w = image.width * scale, h = image.height * scale;
+      context.drawImage(image, x + (cell - w) / 2, y + (cell - h) / 2, w, h);
+    } catch {
+      context.fillStyle = "#ff3b3b";
+      context.fillText("unreadable", x + 20, y + 40);
+    }
+    context.fillStyle = "#141414";
+    context.font = "20px sans-serif";
+    context.fillText(file.name, x, y + cell + 30, cell);
+  }
+  const swatches = Object.entries(brand.palette);
+  const sy = height - 140;
+  swatches.forEach(([name, color], i) => {
+    context.fillStyle = color;
+    context.fillRect(60 + i * 200, sy, 180, 70);
+    context.fillStyle = "#141414";
+    context.font = "18px sans-serif";
+    context.fillText(`${name} ${color}`, 60 + i * 200, sy + 100);
+  });
+  return new Uint8Array(canvas.toBuffer("image/png"));
+}
+var eventPlatforms = /(^|\.)(luma\.com|lu\.ma|eventbrite\.[a-z.]+|meetup\.com|partiful\.com)$/;
+async function brandFromUrl(url, out, options = {}) {
+  let page;
+  try {
+    page = new URL(url);
+  } catch {
+    throw new InputError("Supply a complete https URL.");
+  }
+  if (page.protocol !== "https:") throw new InputError("Supply an https URL.");
+  const existing = options.into ? await readBrand(options.into) : void 0;
+  const target = options.into ? dirname(resolve(options.into)) : resolve(out);
+  const refs = join(target, "refs");
+  if (!existing) {
+    await mkdir(target);
+    await mkdir(refs);
+  } else await mkdir(refs, { recursive: true });
+  const platform = eventPlatforms.test(page.hostname);
+  let html = "";
+  let staticError;
+  try {
+    html = new TextDecoder().decode((await fetchBytes(page.href, 4e6)).bytes);
+  } catch (error) {
+    staticError = error;
+  }
+  let facts = pageFacts(html, page.href);
+  if (staticError || !facts.logos.length) {
+    const rendered = renderedHtml(page.href);
+    if (rendered) {
+      html = rendered;
+      facts = pageFacts(html, page.href);
+    } else if (staticError) throw staticError;
+  }
+  const saved = [];
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const save = async (source, name2, role) => {
+    try {
+      const { bytes } = await fetchBytes(source);
+      const digest = createHash("sha256").update(bytes).digest("hex");
+      if (seen.has(digest)) return;
+      seen.add(digest);
+      const info = await imageInfo(bytes);
+      if (!info) return warnings.push(`Skipped ${source}: not a readable image.`);
+      const isSvg = info.format === "svg";
+      if (role === "logo" && !isSvg && Math.max(info.width ?? 0, info.height ?? 0) < 96)
+        return warnings.push(
+          `Skipped ${source}: ${info.width}\xD7${info.height} is too small for print.`
+        );
+      const data = isSvg ? bytes : await fitImage(bytes);
+      const path = join(refs, `${name2}.${isSvg ? "svg" : "png"}`);
+      await writeFile(path, data);
+      const fitted = isSvg ? info : await imageInfo(data);
+      saved.push({ name: name2, path, role, width: fitted?.width ?? 0, height: fitted?.height ?? 0 });
+      if (!isSvg && data.length < bytes.length)
+        warnings.push(
+          `${name2} was reduced to ${fitted?.width}\xD7${fitted?.height} to stay under 2 MB; keep the original master for print.`
+        );
+    } catch (error) {
+      warnings.push(`Skipped ${source}: ${error.message}`);
+    }
+  };
+  const prefix = existing ? slugify(page.hostname.replace(/^www\./, "").split(".")[0]) : "logo";
+  if (facts.image && !existing?.cover) await save(facts.image, "cover", "cover");
+  const logoSources = platform ? facts.logos.filter((src) => !eventPlatforms.test(new URL(src).hostname)) : [...facts.logos, ...facts.icons];
+  for (const [index, source] of logoSources.slice(0, 8).entries())
+    await save(source, `${prefix}-${index + 1}`, "logo");
+  if (platform)
+    warnings.push(
+      `${page.hostname} is an event platform; its icons are not the brand's. Add the brand's own logos with: makeables brand from-url --url <brand-site> --file ${join(target, "brand.json")}`
+    );
+  const cover = saved.find((file2) => file2.role === "cover");
+  const name = (options.name ?? facts.event ?? facts.title?.split(/\s[|·–-]\s/)[0] ?? page.hostname).trim().slice(0, 60);
+  const logos = saved.filter((file2) => file2.role === "logo").map((file2) => ({
+    id: file2.name,
+    name: file2.name.replace(/-/g, " "),
+    file: relative(target, file2.path)
+  }));
+  for (const logo of logos)
+    Object.assign(logo, { tone: await artTone(await readFile(resolve(target, logo.file))) });
+  const brand = existing ? brandDocumentSchema.parse({
+    ...existing,
+    logos: [
+      ...existing.logos.filter((logo) => !logos.some((entry) => entry.id === logo.id)),
+      ...logos
+    ].slice(0, 8)
+  }) : brandDocumentSchema.parse({
+    ...newBrand(name, options.slug ?? slugify(name)),
+    description: (facts.description ?? `${name} on Makeables.`).slice(0, 400),
+    website: `${page.origin}${page.pathname}`,
+    ...cover ? {
+      cover: relative(target, cover.path),
+      palette: await paletteOf(await readFile(cover.path))
+    } : {},
+    logos
+  });
+  const lines = [
+    page.href,
+    [facts.date && `Date: ${facts.date}`, facts.place && `Place: ${facts.place}`].filter(Boolean).join(" \xB7 "),
+    facts.description ?? ""
+  ].filter(Boolean);
+  const proof = join(refs, "refs-proof.png");
+  const shown = [
+    ...brand.cover ? [{ name: "cover", path: resolve(target, brand.cover) }] : [],
+    ...brand.logos.map((logo) => ({ name: logo.id, path: resolve(target, logo.file) }))
+  ];
+  await writeFile(proof, await refsProof(brand, shown, lines));
+  const file = join(target, "brand.json");
+  await writeBrand(file, brand);
+  if (!brand.cover)
+    warnings.push("No cover image found. Add one to refs/ and set brand.json cover.");
+  if (!brand.logos.length)
+    warnings.push(
+      "No logo found. Ask the user for official logo files or a brand kit page and add them to refs/."
+    );
+  return {
+    path: file,
+    proof,
+    event: { title: facts.title, date: facts.date, place: facts.place },
+    files: saved.map(({ name: name2, path, role, width, height }) => ({
+      name: name2,
+      role,
+      path,
+      width,
+      height
+    })),
+    palette: brand.palette,
+    warnings
+  };
+}
+function referencedImages(value, found = []) {
+  if (typeof value === "string") {
+    const match = value.match(/^data:image\/(?:png|jpeg|jpg|webp|gif|svg\+xml);base64,(.+)$/);
+    if (match) found.push(Uint8Array.from(Buffer.from(match[1], "base64")));
+  } else if (Array.isArray(value)) for (const entry of value) referencedImages(entry, found);
+  else if (value && typeof value === "object")
+    for (const entry of Object.values(value)) referencedImages(entry, found);
+  return found;
+}
+async function imageHash(bytes) {
+  const { data } = await sharp(bytes).flatten({ background: "#ffffff" }).resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer({ resolveWithObject: true });
+  const mean = data.reduce((sum, value) => sum + value, 0) / data.length;
+  return Array.from(data, (value) => value > mean ? "1" : "0").join("");
+}
+function distance(a, b) {
+  let n = 0;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) n++;
+  return n;
+}
+async function checkKitAgainstBrand(kitFile, brandFile) {
+  const brand = await readBrand(brandFile);
+  const brandDir = dirname(resolve(brandFile));
+  const allowed = [];
+  const sources = [
+    ...brand.cover ? [brand.cover] : [],
+    ...brand.logos.map((logo) => logo.file),
+    ...brand.plan?.generated ?? []
+  ];
+  const refsDir = join(brandDir, "refs");
+  try {
+    const { readdir } = await import("fs/promises");
+    for (const entry of await readdir(refsDir))
+      if (imageFile.test(entry) && entry !== "refs-proof.png") sources.push(join("refs", entry));
+  } catch {
+  }
+  for (const source of new Set(sources)) {
+    try {
+      allowed.push({
+        file: source,
+        hash: await imageHash(await readFile(resolve(brandDir, source)))
+      });
+    } catch {
+    }
+  }
+  const kit = await readKit(kitFile);
+  const kitDir = dirname(resolve(kitFile));
+  const pieces = [];
+  for (const item of kit.items) {
+    const path = resolve(kitDir, item.file);
+    const raw = path.endsWith(".json") ? JSON.parse(await readFile(path, "utf8")) : null;
+    const images = raw ? referencedImages(raw) : [];
+    const pkg = await readSubmission(path, false);
+    const previews = /* @__PURE__ */ new Set([pkg.manifest.front, pkg.manifest.back]);
+    for (const entry of pkg.manifest.files)
+      if (entry.mime.startsWith("image/") && !previews.has(entry.path))
+        images.push(pkg.files[entry.path]);
+    const matches = [];
+    let foreign = 0;
+    for (const bytes of images) {
+      let hash;
+      try {
+        hash = await imageHash(bytes);
+      } catch {
+        continue;
+      }
+      const best = allowed.map((entry) => ({ ...entry, d: distance(entry.hash, hash) })).sort((a, b) => a.d - b.d)[0];
+      if (best && best.d <= 10) matches.push(best.file);
+      else foreign++;
+    }
+    const document = pkg.manifest.document ? new TextDecoder().decode(pkg.files[pkg.manifest.document]) : "";
+    if (/"source":"(gallery|sticker|petdex)"/.test(document)) foreign++;
+    pieces.push({ id: item.id, images: images.length, foreign, matches: [...new Set(matches)] });
+  }
+  const stickers = kit.items.length;
+  const issues = [
+    ...pieces.filter((piece) => piece.foreign).map(
+      (piece) => `${piece.id}: ${piece.foreign} image(s) not from the brand refs or generated art.`
+    ),
+    ...brand.plan?.stickers && stickers < brand.plan.stickers ? [`The plan asks for ${brand.plan.stickers} pieces; the kit has ${stickers}.`] : [],
+    ...brand.cover && !pieces.some((piece) => piece.matches.includes(brand.cover)) ? ["No piece uses the event cover."] : [],
+    ...brand.logos.length && !pieces.some((piece) => piece.matches.some((m) => brand.logos.some((logo) => logo.file === m))) ? ["No piece uses a brand logo."] : []
+  ];
+  return { ok: issues.length === 0, brand: brand.slug, pieces, issues };
+}
+async function rasterIdentity(bytes) {
+  return new Uint8Array(
+    await sharp(bytes, { density: 300 }).resize({ width: 1200, height: 1200, fit: "inside", withoutEnlargement: false }).png().toBuffer()
+  );
+}
+async function brandCover(brand, logo, kitCovers) {
+  const width = 1600, height = 900;
+  const canvas = createCanvas(width, height);
+  const context = canvas.getContext("2d");
+  context.fillStyle = brand.palette.paper;
+  context.fillRect(0, 0, width, height);
+  context.fillStyle = brand.palette.accent;
+  context.fillRect(0, height - 24, width, 24);
+  if (logo) {
+    const image = await loadImage(Buffer.from(logo));
+    const scale = Math.min(520 / image.width, 220 / image.height);
+    context.drawImage(image, 80, 80, image.width * scale, image.height * scale);
+  } else {
+    context.fillStyle = brand.palette.ink;
+    context.font = "bold 96px sans-serif";
+    context.fillText(brand.name, 80, 200, width - 160);
+  }
+  for (const [index, bytes] of kitCovers.slice(0, 3).entries()) {
+    const image = await loadImage(Buffer.from(bytes));
+    const box = 440;
+    const scale = Math.min(box / image.width, box / image.height);
+    context.drawImage(
+      image,
+      80 + index * (box + 40),
+      360,
+      image.width * scale,
+      image.height * scale
+    );
+  }
+  return new Uint8Array(canvas.toBuffer("image/png"));
+}
+async function prepareBrand(file) {
+  const brand = await readBrand(file);
+  const pending = brand.kits.filter((kit) => !kit.submission).map((kit) => kit.id);
+  if (!brand.kits.length) throw new InputError("Add a kit with makeables brand add-kit first.");
+  if (pending.length)
+    throw new InputError(
+      `Kits not submitted yet: ${pending.join(", ")}. Run makeables submit --file brand.json; it submits each kit, then the brand.`
+    );
+  const base = dirname(resolve(file));
+  const files = {};
+  const mime = {};
+  const logos = [];
+  for (const logo of brand.logos) {
+    const path = `identity/${logo.id}.png`;
+    files[path] = await rasterIdentity(await readFile(resolve(base, logo.file)));
+    mime[path] = "image/png";
+    logos.push({ ...logo, file: path, tone: logo.tone ?? await artTone(files[path]) });
+  }
+  let cover;
+  if (brand.cover) {
+    cover = "identity/cover.png";
+    files[cover] = await fitImage(await readFile(resolve(base, brand.cover)));
+    mime[cover] = "image/png";
+  }
+  const kitCovers = [];
+  for (const kit of brand.kits)
+    if (kit.file) {
+      const pkg = await readSubmission(resolve(base, kit.file));
+      kitCovers.push(pkg.files[pkg.manifest.front]);
+    }
+  const published = brandPackageDocumentSchema.parse({
+    ...brand,
+    plan: void 0,
+    cover,
+    logos,
+    kits: brand.kits.map(({ file: _file, ...kit }) => kit)
+  });
+  files["brand.json"] = jsonBytes(published);
+  mime["brand.json"] = "application/json";
+  files["cover.png"] = await brandCover(brand, logos[0] && files[logos[0].file], kitCovers);
+  mime["cover.png"] = "image/png";
+  return assemblePackage(
+    {
+      product: "brand",
+      slug: brand.slug,
+      title: brand.name,
+      document: "brand.json",
+      front: "cover.png",
+      assets: {},
+      kits: published.kits.map((kit) => kit.submission)
+    },
+    files,
+    mime
+  );
+}
+var mimeOf = (path) => ({
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg"
+})[extname(path).toLowerCase()] ?? "application/octet-stream";
+var dataUrl = (bytes, type) => `data:${type};base64,${Buffer.from(bytes).toString("base64")}`;
+async function brandView(file) {
+  const brand = await readBrand(file);
+  const base = dirname(resolve(file));
+  const pieces = [];
+  const kits = [];
+  for (const kit of brand.kits) {
+    if (!kit.file) continue;
+    const pkg = await readSubmission(resolve(base, kit.file));
+    if (pkg.manifest.product !== "kit") continue;
+    kits.push({ id: kit.id, name: pkg.manifest.title, href: "#" });
+    for (const item of pkg.manifest.items) {
+      const front = pkg.files[`items/${item.id}/${item.manifest.front}`];
+      const back = item.manifest.back ? pkg.files[`items/${item.id}/${item.manifest.back}`] : void 0;
+      pieces.push({
+        id: `${kit.id}-${item.id}`,
+        name: item.manifest.title,
+        family: kit.family ?? kit.id,
+        product: item.manifest.product,
+        preview: dataUrl(front, "image/png"),
+        ...back ? { back: dataUrl(back, "image/png") } : {}
+      });
+    }
+  }
+  const read = async (path) => path ? dataUrl(await readFile(resolve(base, path)), mimeOf(path)) : void 0;
+  return {
+    slug: brand.slug,
+    name: brand.name,
+    language: brand.language,
+    tagline: brand.tagline,
+    description: brand.description,
+    website: brand.website,
+    palette: brand.palette,
+    layout: brand.layout,
+    cover: await read(brand.cover),
+    logos: await Promise.all(
+      brand.logos.map(async (logo) => ({
+        name: logo.name,
+        src: await read(logo.file),
+        tone: logo.tone ?? await artTone(await readFile(resolve(base, logo.file)))
+      }))
+    ),
+    families: brand.families.length ? brand.families : brand.kits.map((kit) => ({
+      id: kit.family ?? kit.id,
+      name: kit.id,
+      headline: "",
+      description: ""
+    })),
+    kits,
+    pieces
+  };
+}
+async function submitBrand(options) {
+  const brand = await readBrand(options.file);
+  const base = dirname(resolve(options.file));
+  const pending = brand.kits.filter((kit) => !kit.submission && kit.file);
+  if (options.dryRun || options.status) {
+    const kits2 = [];
+    for (const kit of brand.kits) {
+      if (kit.submission) {
+        kits2.push({ id: kit.id, submission: kit.submission });
+        continue;
+      }
+      const result2 = await submitDesign({
+        ...options,
+        file: resolve(base, kit.file),
+        title: void 0
+      });
+      kits2.push({ id: kit.id, ...result2 });
+    }
+    return {
+      product: "brand",
+      slug: brand.slug,
+      title: brand.name,
+      dryRun: Boolean(options.dryRun),
+      kits: kits2,
+      shares: [
+        "brand page copy, palette and layout",
+        `${brand.logos.length} logos`,
+        ...brand.cover ? ["cover"] : []
+      ],
+      review: "Each kit and the brand are reviewed by a Makeables admin before /brands/<slug> is public."
+    };
+  }
+  const kits = [];
+  for (const kit of pending) {
+    const result2 = await submitDesign({
+      ...options,
+      file: resolve(base, kit.file),
+      title: void 0
+    });
+    const id = "receipt" in result2 && result2.receipt ? result2.receipt.id : void 0;
+    if (!id) throw new InputError(`Kit ${kit.id} did not return a submission.`);
+    kit.submission = id;
+    await writeBrand(options.file, brand);
+    kits.push({ id: kit.id, submission: id, state: result2.state });
+  }
+  const pkg = await prepareBrand(options.file);
+  const result = await submitDesign({ ...options, pkg, title: options.title ?? brand.name });
+  return { ...result, slug: brand.slug, kits };
+}
+
+export {
+  readBrand,
+  writeBrand,
+  slugify,
+  newBrand,
+  addBrandKit,
+  artTone,
+  addBrandLogo,
+  paletteOf,
+  pageFacts,
+  refsProof,
+  brandFromUrl,
+  checkKitAgainstBrand,
+  prepareBrand,
+  brandView,
+  submitBrand
+};