@omega.js/web 0.1.0

package/dist/service-worker.js

@@ -0,0 +1,200 @@
+/**
+ * Service-worker build step + build-meta emission (the master-service-worker
+ * successor's plumbing half; the browser half lives in sw/manager.js).
+ *
+ * Every build — dev included — emits to the site root:
+ *   /service-worker.js  - esbuild iife bundle of the consumer's
+ *                         src/service-worker.js (or the packaged default
+ *                         entry), registered by @omega.js/client at scope '/'
+ *                         (at scope '<prefix>/' when the site is mounted
+ *                         under a base path — #360)
+ *   /build.js           - `self.OMEGA_BUILD_JSON = {…}` — the SW's config
+ *                         transport (importScripts can't consume JSON)
+ *   /build.json         - the same meta for page-side consumers
+ *                         (@omega.js/client's version check fetches it)
+ *
+ * The meta carries brand id + cacheBreaker, so the SW's cache name
+ * (`<brand>-<breaker>`) identifies the owning project+build — the takeover
+ * mechanism for one localhost port serving different projects over time.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { brandRepoName, brandRepoOwner } = require('./vendor/config/index.js');
+const { bundle } = require('./vendor/devkit/bundle.js');
+const { getEnvironment } = require('./mode-helpers.js');
+
+const FRAMEWORK_ROOT = path.resolve(__dirname, '..');
+
+// Fallback when @omega.js/client's package.json can't be resolved from the
+// clientEntry path — keep in step with packages/client's firebase dependency.
+const FIREBASE_VERSION_FALLBACK = '12.14.0';
+
+/**
+ * The nearest readable package.json walking up from `dir`.
+ * @param {string} dir - where to start (a file's dirname, or a dir)
+ * @param {number} [hops] - how far up to walk
+ * @returns {object|null} the parsed manifest, or null when none is readable
+ */
+function readPackageUp(dir, hops = 5) {
+  let at = dir || null;
+  for (let hop = 0; at && hop < hops; hop++) {
+    const candidate = path.join(at, 'package.json');
+    if (fs.existsSync(candidate)) {
+      try {
+        return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+      } catch { /* unreadable — keep walking */ }
+    }
+    const parent = path.dirname(at);
+    if (parent === at) break;
+    at = parent;
+  }
+  return null;
+}
+
+/**
+ * The firebase compat CDN version the SW imports — pinned to
+ * @omega.js/client's own firebase dependency so page and worker agree.
+ * @param {string} clientEntry - path to the client entry (walked up to its package.json)
+ * @returns {string}
+ */
+function resolveFirebaseVersion(clientEntry) {
+  const pkg = readPackageUp(clientEntry ? path.dirname(clientEntry) : null);
+  const version = (pkg?.dependencies?.firebase || '').replace(/^[^\d]*/, '');
+
+  return version || FIREBASE_VERSION_FALLBACK;
+}
+
+/**
+ * The versions the built site is actually made of — the framework doing the
+ * building, the client runtime it embeds, that runtime's firebase, and the
+ * node it all ran on. Read from the resolved package manifests, never a
+ * hardcoded list, so a locally linked checkout reports its own version.
+ *
+ * @param {string} [clientEntry] - @omega.js/client entry
+ * @returns {object} name → version
+ */
+function packageVersions(clientEntry) {
+  const web = readPackageUp(__dirname);
+  const client = readPackageUp(clientEntry ? path.dirname(clientEntry) : null);
+  const versions = {};
+
+  if (web?.name && web.version) versions[web.name] = web.version;
+  if (client?.name && client.version) versions[client.name] = client.version;
+  versions.firebase = resolveFirebaseVersion(clientEntry);
+  versions.node = process.version.replace(/^v/, '');
+
+  return versions;
+}
+
+/**
+ * The commit the site was built from — `git rev-parse` in the consumer tree.
+ * An absent repo is an EXPECTED external condition (a tarball, a CI checkout
+ * with no .git, a brand that never ran `git init`), so this answers null
+ * rather than failing a build over it.
+ *
+ * @param {string} [consumerDir] - anywhere inside the consumer's repo
+ * @returns {string|null} the short sha, or null when there is no repo
+ */
+function resolveCommit(consumerDir) {
+  if (!consumerDir) {
+    return null;
+  }
+
+  try {
+    return execFileSync('git', ['rev-parse', '--short', 'HEAD'], {
+      cwd: consumerDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Bundle the service worker to `<outDir>/service-worker.js`.
+ * @param {object} options
+ * @param {string} options.consumerDir - the consumer site src (holds an optional service-worker.js)
+ * @param {string} options.outDir - the site output dir
+ * @param {string} [options.clientEntry] - @omega.js/client entry (firebase version source)
+ * @param {boolean} [options.dev] - dev mode: no minify
+ * @returns {Promise<string>} the service worker URL ('/service-worker.js')
+ */
+async function buildServiceWorker(options) {
+  const consumerEntry = path.join(options.consumerDir, 'service-worker.js');
+  const entry = fs.existsSync(consumerEntry)
+    ? consumerEntry
+    : path.resolve(FRAMEWORK_ROOT, 'sw', 'entry.js');
+
+  // The ONE esbuild wrapper (#736/#737): @omega.js/devkit composes the minify
+  // rule and the production `@dev-only` strip this call used to spell out by
+  // hand. `outfile` (#737) is why it can — the worker must land at exactly
+  // `/service-worker.js`, the scope @omega.js/client registers.
+  await bundle({
+    frameworkRoot: FRAMEWORK_ROOT,
+    entries: [entry],
+    dev: Boolean(options.dev),
+    // Classic worker script — importScripts() only exists outside module workers
+    format: 'iife',
+    outfile: path.join(options.outDir, 'service-worker.js'),
+    alias: { '@omega.js/web/service-worker': path.resolve(FRAMEWORK_ROOT, 'sw', 'manager.js') },
+    define: {
+      'process.env.NODE_ENV': options.dev ? '"development"' : '"production"',
+      __OMEGA_FIREBASE_VERSION__: JSON.stringify(resolveFirebaseVersion(options.clientEntry)),
+    },
+  });
+
+  return '/service-worker.js';
+}
+
+/**
+ * Emit /build.js (JSONP for the SW) + /build.json (page-side) into outDir.
+ * @param {object} options
+ * @param {object} options.siteData - resolved omega config (brand/cloud)
+ * @param {string} options.outDir
+ * @param {string} [options.environment] - the build's environment (#717, read through the one surface)
+ * @param {string} [options.version] - the consumer package version
+ * @param {object} [options.manifest] - buildAssets() manifest (main bundle
+ *   URLs — consumed by the SW's cache warm, which is currently disabled
+ *   behind its CACHE_WARMING_ENABLED flag; kept so a flag flip just works)
+ * @param {string} [options.consumerDir] - the consumer site src (the commit lookup's cwd)
+ * @param {string} [options.clientEntry] - @omega.js/client entry (version source)
+ * @returns {object} the emitted meta
+ */
+function writeBuildMeta(options) {
+  const site = options.siteData || {};
+  const now = new Date();
+  const owner = brandRepoOwner(site);
+  const repo = brandRepoName(site);
+  const meta = {
+    brand: site.brand?.id || 'default',
+    name: site.brand?.name || site.brand?.id || 'default',
+    environment: getEnvironment.call(options),
+    version: options.version || '0.0.0',
+    // `timestamp` is the key @omega.js/client's version check reads
+    timestamp: now.toISOString(),
+    buildTime: now.toISOString(),
+    cacheBreaker: now.getTime(),
+    // The rest of the manifest the /status page shows (#13): what skin the
+    // site wears, what it is made of, where it lives, and which commit it came
+    // from. All derived at build time — nothing here is authored twice.
+    theme: site.theme?.id || null,
+    packages: packageVersions(options.clientEntry),
+    repo: owner && repo ? { user: owner, name: repo } : null,
+    commit: resolveCommit(options.consumerDir),
+    assets: {
+      js: options.manifest?.js?.main || null,
+      css: options.manifest?.css?.main || null,
+    },
+    firebase: site.cloud?.config || null,
+  };
+
+  fs.mkdirSync(options.outDir, { recursive: true });
+  fs.writeFileSync(path.join(options.outDir, 'build.json'), `${JSON.stringify(meta, null, 2)}\n`);
+  fs.writeFileSync(path.join(options.outDir, 'build.js'), `self.OMEGA_BUILD_JSON = ${JSON.stringify(meta)};\n`);
+
+  return meta;
+}
+
+module.exports = { buildServiceWorker, writeBuildMeta, resolveFirebaseVersion };

package/dist/social-pages.js

@@ -0,0 +1,142 @@
+/**
+ * Social shortlink pages (#429) — legacy UJM generated a redirect page per
+ * social (`/spotify`, `/youtube`, `/discord`, …) from the brand's socials
+ * block, and the omega footer links some of them site-wide, so every migrated
+ * brand 404'd its own links until this lane existed. A brand never hand-writes
+ * these pages: the `socials` config block IS the declaration.
+ *
+ *   socials: {
+ *     twitter: 'somiibo',                                   // handle
+ *     spotify: { handle: 'somiibo', redirect: 'https://…' } // handle + its own target
+ *   }
+ *
+ * The string form is a handle, exactly as every other socials consumer reads
+ * it (JSON-LD sameAs, the footer row, `omega_social`) — the profile URL
+ * derives from template-kit's platform patterns, the ONE home of that
+ * mapping. The object form adds the case that pattern cannot express: a
+ * destination that is NOT the profile URL (kirue's Spotify ARTIST page, where
+ * the handle still names the profile sameAs points at).
+ *
+ * The generated pages ride the shared redirect-page shape (redirect-page.js):
+ * source strings registered as virtual templates on the same lane as the
+ * framework's default pages.
+ */
+const { SOCIAL_URLS } = require('./vendor/template-kit/data/social-urls.js');
+const { redirectPage } = require('./redirect-page.js');
+
+// A platform key is a URL segment — the shortlink is literally `/<key>`.
+const KEY_PATTERN = /^[a-z][a-z0-9-]*$/;
+
+// The keys an entry's object form may carry. Anything else is a typo, and a
+// typo'd redirect target silently ships the derived URL instead.
+const ENTRY_KEYS = ['handle', 'redirect'];
+
+/**
+ * The profile URL a handle derives on a platform — template-kit's pattern set,
+ * the same one `omega_social` renders from. An unknown platform derives
+ * nothing.
+ * @param {string} key - platform key
+ * @param {string} handle
+ * @returns {string} the profile URL, or '' when it cannot be derived
+ */
+function profileUrl(key, handle) {
+  const pattern = SOCIAL_URLS[key];
+  if (!pattern || !handle) return '';
+
+  return pattern.replace('%s', handle);
+}
+
+/**
+ * Read and validate the `socials` config block. A malformed entry is an ERROR
+ * (a shortlink that silently fails to generate is a 404 on a link the footer
+ * prints on every page); an entry with NOTHING to point at — a blank
+ * placeholder handle, or a platform with no known URL pattern and no explicit
+ * redirect — declares no page, the same way the footer and sameAs already skip
+ * it.
+ * @param {object} [config] - the raw socials value
+ * @returns {Array<{ key: string, handle: string, url: string, redirect: string }>}
+ * @throws {Error} on a bad shape or an unusable platform key
+ */
+function readSocials(config) {
+  if (config === undefined || config === null) return [];
+
+  if (typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(
+      `socials must be a map of platform → handle — got ${Array.isArray(config) ? 'array' : typeof config}`,
+    );
+  }
+
+  return Object.entries(config)
+    .map(([key, value]) => readSocial(key, value))
+    .filter((entry) => entry !== null);
+}
+
+/**
+ * Read one socials entry.
+ * @param {string} key - the platform key (the config key)
+ * @param {string|object} value - a handle, or { handle, redirect }
+ * @returns {object|null} the resolved entry, or null when it points nowhere
+ */
+function readSocial(key, value) {
+  // An unset platform is how a legacy config spells "we don't have one".
+  if (value === undefined || value === null || value === '') return null;
+
+  const at = `socials.${KEY_PATTERN.test(key) ? key : JSON.stringify(key)}`;
+
+  if (!KEY_PATTERN.test(key)) {
+    throw new Error(
+      `${at} is not a usable platform key — a key is lowercase, starts with a letter, and names the shortlink URL (/${key})`,
+    );
+  }
+
+  if (typeof value === 'string') {
+    const url = profileUrl(key, value);
+    return url ? { key, handle: value, url, redirect: url } : null;
+  }
+
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${at} must be a handle string or { handle, redirect } — got ${Array.isArray(value) ? 'array' : typeof value}`);
+  }
+
+  const unknown = Object.keys(value).find((entryKey) => !ENTRY_KEYS.includes(entryKey));
+  if (unknown) {
+    throw new Error(`${at} has an unknown key "${unknown}" — an entry carries handle and redirect`);
+  }
+
+  const handle = value.handle === undefined ? '' : value.handle;
+  const redirect = value.redirect === undefined ? '' : value.redirect;
+
+  if (typeof handle !== 'string') {
+    throw new Error(`${at}.handle must be a string — got ${typeof handle}`);
+  }
+  if (typeof redirect !== 'string') {
+    throw new Error(`${at}.redirect must be a URL string — got ${typeof redirect}`);
+  }
+  if (!handle && !redirect) {
+    throw new Error(`${at} carries neither a handle nor a redirect — drop the entry, or say where /${key} goes`);
+  }
+
+  const url = profileUrl(key, handle);
+  // The redirect target WINS: the profile URL is what sameAs reads, and the
+  // two are only ever different because the brand said so.
+  const destination = redirect || url;
+
+  return destination ? { key, handle, url, redirect: destination } : null;
+}
+
+/**
+ * The generated page of one socials entry: a redirect shortlink at /<key>.
+ * @param {Array<object>} entries - readSocials output
+ * @returns {Array<{ virtual: string, label: string, url: string, raw: string }>}
+ */
+function socialPages(entries) {
+  return entries.map((entry) => redirectPage({
+    virtual: `omega-socials/${entry.key}.html`,
+    label: `socials.${entry.key}`,
+    url: `/${entry.key}`,
+    redirect: entry.redirect,
+    note: `Social shortlink generated by @omega.js/web from socials.${entry.key} (#429).`,
+  }));
+}
+
+module.exports = { readSocials, socialPages };

package/dist/srcset.js

@@ -0,0 +1,67 @@
+/**
+ * The ONE srcset candidate parser (#362). Both HTML passes rewrite the URL of
+ * every candidate in a `srcset` attribute — cachebreak-html.js stamps it,
+ * path-prefix.js mounts it — and each carried its own `value.split(',')`, so
+ * the same bug shipped twice: a candidate URL may legally contain a comma (a
+ * `data:` payload, a query string like `?w=100,200`), and splitting on every
+ * comma cuts those in half.
+ *
+ * ⚠️ FORMAT TWIN — keep in step with `core/js/libs/srcset.js`, the ESM copy the
+ * runtime lazy-loader uses for the `data-srcset` lane these passes defer to
+ * (#367). A change to how a candidate is parsed belongs in BOTH files.
+ *
+ * Candidates are parsed the way the HTML srcset grammar actually works: the
+ * URL is a run of NON-WHITESPACE characters (commas inside it belong to the
+ * URL), the boundary is the comma that ends a candidate — either trailing the
+ * URL itself (descriptor-less form) or after the descriptor list.
+ */
+
+/**
+ * Rewrite every candidate URL in a srcset value, keeping the descriptors and
+ * the `, ` separator the passes have always emitted.
+ * @param {string} value - srcset attribute value
+ * @param {Function} mapUrl - (url: string) → string, the pass's URL rewrite
+ * @returns {string}
+ */
+function mapSrcset(value, mapUrl) {
+  const input = String(value);
+  const candidates = [];
+  let i = 0;
+
+  while (i < input.length) {
+    // Leading whitespace and the empty candidates a stray comma leaves behind
+    while (i < input.length && /[\s,]/.test(input[i])) i++;
+    if (i >= input.length) break;
+
+    const urlStart = i;
+    while (i < input.length && !/\s/.test(input[i])) i++;
+    const url = input.slice(urlStart, i);
+
+    // A URL ending in commas IS the boundary (the descriptor-less form) —
+    // strip them and the candidate is done; otherwise the descriptors run to
+    // the next comma outside a parenthesized group.
+    if (url.endsWith(',')) {
+      candidates.push({ url: url.replace(/,+$/, ''), descriptor: '' });
+      continue;
+    }
+
+    const descriptorStart = i;
+    let depth = 0;
+    while (i < input.length) {
+      const char = input[i];
+      if (char === '(') depth++;
+      else if (char === ')') depth = Math.max(0, depth - 1);
+      else if (char === ',' && depth === 0) break;
+      i++;
+    }
+
+    candidates.push({ url, descriptor: input.slice(descriptorStart, i).trim() });
+    i++; // the boundary comma
+  }
+
+  return candidates
+    .map(({ url, descriptor }) => [mapUrl(url), ...(descriptor ? [descriptor] : [])].join(' '))
+    .join(', ');
+}
+
+module.exports = { mapSrcset };

package/dist/static-assets.js

@@ -0,0 +1,154 @@
+/**
+ * Static-asset channel: files that ship to the built site VERBATIM (no
+ * bundling) — the framework's own core images first, then the brand's
+ * minted identity set bridged from <brandRoot>/.omega/assets (manager
+ * assets service output: favicons, brandmark, social image), then the
+ * consumer's own src/assets layer, copied LAST so consumer files win
+ * collisions. Entries whose source doesn't exist are skipped, so a brand
+ * with no minted assets builds clean. buildSite runs the copies as its
+ * 'static' phase.
+ *
+ * The consumer layer is the WHOLE src/assets tree, not just images (#295):
+ * audio, video, downloadable documents — a page that references
+ * /assets/audio/alarm.mp3 got a 404 while the file sat in src/. The
+ * pipeline-owned lanes are the exception (PIPELINE_LANES).
+ *
+ * The copies also mirror the shipped favicon.ico to the site ROOT, because
+ * browsers probe /favicon.ico with no link tag involved (#161).
+ */
+const path = require('node:path');
+const jetpack = require('fs-jetpack');
+const { PATHS } = require('./paths.js');
+
+// The ASSET PIPELINE owns these src/assets children — it reads them as layer
+// roots (assets.js) and writes its own dist/assets/<lane> from the layered
+// union: content-hashed js/css bundles, and fonts pruned to the faces some
+// emitted stylesheet references. The static phase runs after it, so a verbatim
+// copy would drop unbundled sources beside the bundles and undo the font prune.
+const PIPELINE_LANES = new Set(['js', 'css', 'fonts']);
+
+// The bridged VECTOR brandmark's site path — named because two lanes address
+// it: the mint bridge below writes it, and brandmarkSvgUrl reports it.
+const BRANDMARK_SVG_DEST = 'assets/images/brand/brandmark.svg';
+
+// <brandRoot>/.omega/assets → site paths. This is the mint contract:
+// head.html's favicon links + brand.images.{brandmark,social} config URLs
+// resolve against these destinations.
+const MINT_BRIDGE = [
+  { src: ['favicon'], dest: 'assets/images/favicon' },
+  { src: ['logo', 'brandmark', 'color-x.svg'], dest: BRANDMARK_SVG_DEST },
+  { src: ['logo', 'brandmark', 'color-512.png'], dest: 'assets/images/brand/brandmark.png' },
+  { src: ['social', 'brandmark', 'color-1024.png'], dest: 'assets/images/brand/social.png' },
+];
+
+/**
+ * Resolve the ordered static copy list for a consumer build: minted brand
+ * identity first, the consumer's own asset layer last (it wins collisions).
+ * Sources that don't exist are dropped.
+ * @param {object} options
+ * @param {string|null} options.brandRoot - brand monorepo root (standalone projects: the target root)
+ * @param {string} options.assetsDir - the consumer's src/assets
+ * @param {string} [options.coreDir] - the framework core layer (default: packaged core)
+ * @returns {Array<{ src: string, dest: string }>}
+ */
+function resolveStaticDirs(options) {
+  const entries = [];
+
+  // Framework-shipped images (core/images → /assets/images/core): the
+  // packaged pictures core templates reference by fixed URL — today the
+  // exit popup's social-proof faces. First, so both brand layers win.
+  entries.push({ src: path.join(options.coreDir || PATHS.core, 'images'), dest: 'assets/images/core' });
+
+  if (options.brandRoot) {
+    const mintRoot = path.join(options.brandRoot, '.omega', 'assets');
+    for (const { src, dest } of MINT_BRIDGE) {
+      entries.push({ src: path.join(mintRoot, ...src), dest });
+    }
+  }
+
+  // images/ stays its OWN entry (imagemin and the favicon probe both address
+  // that destination by name); everything else the consumer keeps under
+  // src/assets rides beside it, one entry per child, in a stable order.
+  // Hidden entries never ride: the widened lane listed .DS_Store & co. as
+  // content and shipped Finder noise to dist.
+  entries.push({ src: path.join(options.assetsDir, 'images'), dest: 'assets/images' });
+  for (const name of (jetpack.list(options.assetsDir) || []).sort()) {
+    if (name.startsWith('.') || name === 'images' || PIPELINE_LANES.has(name)) continue;
+    entries.push({ src: path.join(options.assetsDir, name), dest: `assets/${name}` });
+  }
+
+  return entries.filter((entry) => jetpack.exists(entry.src));
+}
+
+/**
+ * Whether a favicon set will ship with these static copies — the head only
+ * renders its favicon/manifest links when the minted set (or a consumer-
+ * authored one) actually exists, so a virgin brand serves zero dangling
+ * links (cp194 wizard-rehearsal catch).
+ * @param {Array<{ src: string, dest: string }>} staticDirs - From resolveStaticDirs().
+ * @returns {boolean}
+ */
+function hasFaviconSet(staticDirs) {
+  return (staticDirs || []).some(({ src, dest }) =>
+    (dest === 'assets/images/favicon' && jetpack.exists(path.join(src, 'site.webmanifest')) === 'file')
+    || (dest === 'assets/images' && jetpack.exists(path.join(src, 'favicon', 'site.webmanifest')) === 'file'));
+}
+
+/**
+ * The site url of the VECTOR brandmark when these static copies will ship one
+ * — same shape as hasFaviconSet, and the same reason: whether the mint
+ * produced an svg is a build-time fact, so the templates that render the
+ * VISIBLE logo (nav, footer, app sidebar) read it off the asset manifest
+ * instead of guessing a filename ([#467](https://github.com/Omega-JS-Stack/omega/issues/467)).
+ * `brand.images.brandmark` stays the RASTER it has always been — payment sync
+ * (the Stripe/PayPal product image) and OG/social cards need one.
+ * @param {Array<{ src: string, dest: string }>} staticDirs - From resolveStaticDirs().
+ * @returns {string|null}
+ */
+function brandmarkSvgUrl(staticDirs) {
+  const shipped = (staticDirs || []).some(({ src, dest }) =>
+    (dest === BRANDMARK_SVG_DEST && jetpack.exists(src) === 'file')
+    || (dest === 'assets/images' && jetpack.exists(path.join(src, 'brand', 'brandmark.svg')) === 'file'));
+
+  return shipped ? `/${BRANDMARK_SVG_DEST}` : null;
+}
+
+/**
+ * Copy the resolved entries into the build output, in order (later entries
+ * overwrite earlier ones — that's the consumer-wins contract), then mirror
+ * the shipped favicon.ico to the site root.
+ * @param {object} options
+ * @param {Array<{ src: string, dest: string }>} [options.staticDirs]
+ * @param {string} options.outDir
+ * @returns {{ copied: number, rootFavicon: boolean }}
+ */
+function copyStaticAssets(options) {
+  let copied = 0;
+
+  for (const { src, dest } of options.staticDirs || []) {
+    jetpack.copy(src, path.join(options.outDir, dest), { overwrite: true });
+    copied += 1;
+  }
+
+  return { copied, rootFavicon: mirrorRootFavicon(options.outDir) };
+}
+
+/**
+ * Mirror the shipped favicon set's .ico to <outDir>/favicon.ico. Browsers
+ * probe /favicon.ico directly (no link tag), so the built site answers it in
+ * dev and in production alike. Sourced from the COPIED set, so the
+ * consumer-wins collision result is what lands at the root; no set shipped,
+ * nothing to mirror.
+ * @param {string} outDir
+ * @returns {boolean} Whether a root favicon.ico was written.
+ */
+function mirrorRootFavicon(outDir) {
+  const shipped = path.join(outDir, 'assets', 'images', 'favicon', 'favicon.ico');
+  if (jetpack.exists(shipped) !== 'file') return false;
+
+  jetpack.copy(shipped, path.join(outDir, 'favicon.ico'), { overwrite: true });
+
+  return true;
+}
+
+module.exports = { resolveStaticDirs, copyStaticAssets, hasFaviconSet, brandmarkSvgUrl };