@worldcoin/nucleus 0.1.4

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/wifi-signal-none-solid.imageset/wifi-signal-none-solid.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M1.62695 7.33303C7.35336 1.5028 16.6461 1.50255 22.3711 7.33303L23.0088 7.98245L22.4219 8.67874L11.999 21.0166L0.989258 7.98245L1.62695 7.33303Z" fill="currentColor"/>
+</svg>

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/wifi-solid.imageset/Contents.json

@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "wifi-solid.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/wifi-solid.imageset/wifi-solid.svg

@@ -0,0 +1,6 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12.081 20.359C12.7321 20.359 13.2599 19.831 13.2599 19.1798C13.2599 18.5286 12.7321 18.0007 12.081 18.0007C11.4299 18.0007 10.902 18.5286 10.902 19.1798C10.902 19.831 11.4299 20.359 12.081 20.359Z" fill="currentColor"/>
+<path d="M11.9995 3.25195C16.0776 3.25203 19.6877 4.89009 22.3276 7.53223L20.9136 8.94531C18.6312 6.66102 15.5225 5.25203 11.9995 5.25195C8.47814 5.25195 5.29399 6.69501 3.00537 9.02539L1.57764 7.62402C4.22695 4.92617 7.91968 3.25195 11.9995 3.25195Z" fill="currentColor"/>
+<path d="M12.0807 7.99949C15.025 7.99949 17.5774 9.2484 19.3786 11.228L17.8991 12.5737C16.4566 10.9884 14.4321 9.99949 12.0807 9.99949C9.73163 9.99957 7.6246 11.0278 6.18325 12.6626L4.68325 11.3403C6.4885 9.29271 9.13407 7.99957 12.0807 7.99949Z" fill="currentColor"/>
+<path d="M12.0809 12.9986C13.866 12.9986 15.3344 13.9102 16.1912 15.2632L14.5018 16.3336C13.9883 15.5227 13.1381 14.9986 12.0809 14.9986C11.0299 14.9986 10.1098 15.5657 9.61016 16.4156L7.88555 15.4029C8.7284 13.9688 10.2897 12.9986 12.0809 12.9986Z" fill="currentColor"/>
+</svg>

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/xmark-outline.imageset/Contents.json

@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "xmark-outline.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/xmark-outline.imageset/xmark-outline.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.6758 5.6214L18.3919 18.3911M5.67578 18.2414L18.2931 5.72017" stroke="currentColor" stroke-width="2" stroke-miterlimit="10"/>
+</svg>

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/xmark-regular.imageset/Contents.json

@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "xmark-regular.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/xmark-regular.imageset/xmark-regular.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12 10.555L17.5879 5.01007L18.9961 6.42999L13.4111 11.972L19.1006 17.6859L18.3916 18.3909L17.6836 19.097L11.9912 13.3812L6.37891 18.9515L4.9707 17.5316L10.5801 11.9642L4.9668 6.32745L6.38477 4.91534L12 10.555Z" fill="currentColor"/>
+</svg>

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/xmark-solid.imageset/Contents.json

@@ -0,0 +1,16 @@
+{
+  "images": [
+    {
+      "filename": "xmark-solid.svg",
+      "idiom": "universal"
+    }
+  ],
+  "info": {
+    "author": "xcode",
+    "version": 1
+  },
+  "properties": {
+    "preserves-vector-representation": true,
+    "template-rendering-intent": "template"
+  }
+}

package/ios/Sources/NucleusIcons/Resources/Icons.xcassets/xmark-solid.imageset/xmark-solid.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12 10.5549L17.5879 5.01001L18.9961 6.42993L13.4111 11.9719L19.1006 17.6858L18.3916 18.3909L17.6836 19.0969L11.9912 13.3811L6.37891 18.9514L4.9707 17.5315L10.5801 11.9641L4.9668 6.32739L6.38477 4.91528L12 10.5549Z" fill="currentColor"/>
+</svg>

package/ios/Sources/NucleusTokens/TokenResolvable.swift

@@ -0,0 +1,14 @@
+/// A Nucleus token type that can be resolved from its type-scoped wire token string.
+///
+/// The SDUI backend emits type-scoped tokens (the namespace the resolver type already implies is
+/// stripped): a typography token is `s3`, a color is `text.primary`, a button is `inverse.32`, and
+/// an icon is `name.variant`. Each Nucleus primitive conforms in its own module (via a generated
+/// `+TokenResolvable.swift`), so a consumer only links the modules it actually imports.
+///
+/// `resolve(token:)` returns `nil` for an unknown token; conformances also trip `assertionFailure`
+/// in debug builds so a stale or mistyped token surfaces during development rather than silently
+/// falling through.
+public protocol TokenResolvable {
+    associatedtype ResolvedType
+    static func resolve(token: String) -> ResolvedType?
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@worldcoin/nucleus",
+  "version": "0.1.4",
+  "private": false,
+  "description": "Design tokens for the World ecosystem",
+  "type": "module",
+  "scripts": {
+    "build": "npm run clean && tsx tokens/build/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint",
+    "format": "prettier --write \"**/*.json\"",
+    "format:check": "prettier --check \"**/*.json\"",
+    "clean": "rm -rf build"
+  },
+  "dependencies": {
+    "handlebars": "^4.7.9"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "oxlint": "^1.51.0",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/tokens/build/buttons.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+import { generateAndroidButtons } from '../formats/buttons-android.js';
+import { generateIOSButtons } from '../formats/buttons-ios.js';
+import {
+  generateWebButtonJson,
+  loadButtonDefinition,
+  resolveButtonStyles,
+} from '../formats/buttons.js';
+import {
+  ANDROID_TOKENS_OUT,
+  IOS_BUTTONS_OUT,
+  ROOT,
+  WEB_OUT,
+  logStage,
+} from './shared.js';
+
+export const BUTTON_SOURCE = 'tokens/definitions/component/button.json';
+
+function writeOut(relPath: string, content: string): void {
+  const absolute = resolve(ROOT, relPath);
+  mkdirSync(resolve(absolute, '..'), { recursive: true });
+  writeFileSync(absolute, content);
+}
+
+export function buildButtons(): void {
+  const styles = resolveButtonStyles(loadButtonDefinition(BUTTON_SOURCE));
+
+  const iosOut = `${IOS_BUTTONS_OUT}/NucleusButton+Defaults.swift`;
+  writeOut(iosOut, generateIOSButtons(styles));
+
+  const androidOut = `${ANDROID_TOKENS_OUT}/NucleusButtons.kt`;
+  writeOut(androidOut, generateAndroidButtons(styles));
+
+  const webOut = `${WEB_OUT}/nucleus-button.json`;
+  writeOut(webOut, generateWebButtonJson(styles));
+
+  logStage('tokens/definitions/component/button', [
+    ['ios', iosOut],
+    ['android', androidOut],
+    ['web', webOut],
+  ]);
+}

package/tokens/build/colors.ts

@@ -0,0 +1,98 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+import {
+  generateAndroidPrimitiveColors,
+  generateAndroidSemanticColors,
+} from '../formats/colors-android.js';
+import { generateIOSColors } from '../formats/colors-ios.js';
+import { generateWebColorCss, generateWebColorJson } from '../formats/colors-web.js';
+import { loadColorTokens } from '../formats/loaders.js';
+import { ANDROID_TOKENS_OUT, IOS_COLORS_OUT, ROOT, WEB_OUT, logStage } from './shared.js';
+
+const PRIMITIVE_SOURCE = 'tokens/definitions/color/primitive.json';
+const SEMANTIC_LIGHT_SOURCE = 'tokens/definitions/color/semantic.light.json';
+const SEMANTIC_DARK_SOURCE = 'tokens/definitions/color/semantic.dark.json';
+
+interface ColorBuildTarget {
+  source: string;
+  androidFileName: string;
+  androidObjectName: string;
+  webBaseName: string;
+  /** When true, treat as primitive (no reference resolution). */
+  primitive?: boolean;
+}
+
+const targets: ColorBuildTarget[] = [
+  {
+    source: PRIMITIVE_SOURCE,
+    androidFileName: 'NucleusPrimitiveColors.kt',
+    androidObjectName: 'NucleusPrimitiveColors',
+    webBaseName: 'nucleus-primitive-colors',
+    primitive: true,
+  },
+  {
+    source: SEMANTIC_LIGHT_SOURCE,
+    androidFileName: 'NucleusSemanticColorsLight.kt',
+    androidObjectName: 'NucleusSemanticColorsLight',
+    webBaseName: 'nucleus-semantic-colors-light',
+  },
+  {
+    source: SEMANTIC_DARK_SOURCE,
+    androidFileName: 'NucleusSemanticColorsDark.kt',
+    androidObjectName: 'NucleusSemanticColorsDark',
+    webBaseName: 'nucleus-semantic-colors-dark',
+  },
+];
+
+function writeOut(relPath: string, content: string): void {
+  const absolute = resolve(ROOT, relPath);
+  mkdirSync(resolve(absolute, '..'), { recursive: true });
+  writeFileSync(absolute, content);
+}
+
+function buildAndroidAndWebColors(): void {
+  for (const target of targets) {
+    const tokens = loadColorTokens(target.source);
+
+    const androidContent = target.primitive
+      ? generateAndroidPrimitiveColors(tokens)
+      : generateAndroidSemanticColors(target.androidObjectName, tokens);
+    const androidOut = `${ANDROID_TOKENS_OUT}/${target.androidFileName}`;
+    writeOut(androidOut, androidContent);
+
+    const cssOut = `${WEB_OUT}/${target.webBaseName}.css`;
+    const jsonOut = `${WEB_OUT}/${target.webBaseName}.json`;
+    writeOut(cssOut, generateWebColorCss(tokens));
+    writeOut(jsonOut, generateWebColorJson(tokens));
+
+    logStage(target.source, [
+      ['android', androidOut],
+      ['web', cssOut],
+      ['web', jsonOut],
+    ]);
+  }
+}
+
+// The iOS build sits outside the per-source loop because the generated
+// NucleusColor+Semantics.swift merges light + dark into a single file.
+function buildIOSColors(): void {
+  const { primitivesContent, semanticsContent } = generateIOSColors({
+    primitiveSource: PRIMITIVE_SOURCE,
+    semanticLightSource: SEMANTIC_LIGHT_SOURCE,
+    semanticDarkSource: SEMANTIC_DARK_SOURCE,
+  });
+
+  writeOut(`${IOS_COLORS_OUT}/NucleusColor+Primitives.swift`, primitivesContent);
+  writeOut(`${IOS_COLORS_OUT}/NucleusColor+Semantics.swift`, semanticsContent);
+
+  logStage('tokens/definitions/color (ios)', [
+    ['ios', `${IOS_COLORS_OUT}/NucleusColor+Primitives.swift`],
+    ['ios', `${IOS_COLORS_OUT}/NucleusColor+Semantics.swift`],
+  ]);
+}
+
+export function buildColors(): void {
+  buildAndroidAndWebColors();
+  buildIOSColors();
+}

package/tokens/build/fonts.ts

@@ -0,0 +1,100 @@
+import { cpSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+import { generateAndroidFonts } from '../formats/fonts-android.js';
+import { generateIOSFonts } from '../formats/fonts-ios.js';
+import { generateWebFonts } from '../formats/fonts-web.js';
+import { loadFontDefinitions } from '../formats/loaders.js';
+import { snakeCase } from '../formats/shared.js';
+import type { FontFamily } from '../formats/loaders.js';
+import type { FontToken } from '../formats/loaders.js';
+import {
+  ANDROID_RES_OUT,
+  ANDROID_TOKENS_OUT,
+  IOS_FONTS_OUT,
+  IOS_FONTS_RESOURCES_OUT,
+  ROOT,
+  WEB_FONTS_OUT,
+  WEB_OUT,
+  logStage,
+} from './shared.js';
+
+const FONT_SOURCE = 'tokens/definitions/font/fonts.json';
+const FONT_DEFINITIONS_DIR = 'tokens/definitions/font';
+
+function writeOut(relPath: string, content: string): void {
+  const absolute = resolve(ROOT, relPath);
+  mkdirSync(resolve(absolute, '..'), { recursive: true });
+  writeFileSync(absolute, content);
+}
+
+function copyFile(fromRel: string, toRel: string): void {
+  const from = resolve(ROOT, fromRel);
+  const to = resolve(ROOT, toRel);
+  mkdirSync(resolve(to, '..'), { recursive: true });
+  cpSync(from, to);
+}
+
+function buildIOSFonts(families: FontFamily[], tokens: FontToken[]): void {
+  const swiftOut = `${IOS_FONTS_OUT}/NucleusFont+Defaults.swift`;
+  writeOut(swiftOut, generateIOSFonts(tokens));
+
+  const copied: string[] = [];
+  for (const family of families) {
+    const dest = `${IOS_FONTS_RESOURCES_OUT}/${family.file}`;
+    copyFile(`${FONT_DEFINITIONS_DIR}/${family.file}`, dest);
+    copied.push(dest);
+  }
+
+  logStage('tokens/definitions/font (ios)', [
+    ['ios', swiftOut],
+    ...copied.map((path) => ['ios', path] as const),
+  ]);
+}
+
+function buildAndroidFonts(families: FontFamily[], tokens: FontToken[]): void {
+  const kotlinOut = `${ANDROID_TOKENS_OUT}/NucleusFonts.kt`;
+  writeOut(kotlinOut, generateAndroidFonts(tokens));
+
+  const copied: string[] = [];
+  for (const family of families) {
+    const resource = snakeCase(family.file);
+    const dest = `${ANDROID_RES_OUT}/font/${resource}.ttf`;
+    copyFile(`${FONT_DEFINITIONS_DIR}/${family.file}`, dest);
+    copied.push(dest);
+  }
+
+  logStage('tokens/definitions/font (android)', [
+    ['android', kotlinOut],
+    ...copied.map((path) => ['android', path] as const),
+  ]);
+}
+
+function buildWebFonts(families: FontFamily[], tokens: FontToken[]): void {
+  const { variablesCss, json } = generateWebFonts(tokens);
+
+  const cssOut = `${WEB_OUT}/nucleus-fonts.css`;
+  const jsonOut = `${WEB_OUT}/nucleus-fonts.json`;
+  writeOut(cssOut, variablesCss);
+  writeOut(jsonOut, json);
+
+  const copied: string[] = [];
+  for (const family of families) {
+    const dest = `${WEB_FONTS_OUT}/${family.file}`;
+    copyFile(`${FONT_DEFINITIONS_DIR}/${family.file}`, dest);
+    copied.push(dest);
+  }
+
+  logStage('tokens/definitions/font (web)', [
+    ['web', cssOut],
+    ['web', jsonOut],
+    ...copied.map((path) => ['web', path] as const),
+  ]);
+}
+
+export function buildFonts(): void {
+  const { families, tokens } = loadFontDefinitions(FONT_SOURCE);
+  buildIOSFonts(families, tokens);
+  buildAndroidFonts(families, tokens);
+  buildWebFonts(families, tokens);
+}

package/tokens/build/icons.ts

@@ -0,0 +1,128 @@
+import { cpSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+import {
+  ICON_DEFINITIONS_DIR,
+  discoverIconTokens,
+  iconAssetBaseName,
+  type IconToken,
+  type IconVariant,
+} from '../formats/icons-shared.js';
+import {
+  androidDrawableName,
+  generateAndroidIcons,
+  svgToVectorDrawable,
+} from '../formats/icons-android.js';
+import {
+  catalogContentsJson,
+  generateIOSIcons,
+  imagesetContentsJson,
+  planIOSImagesets,
+} from '../formats/icons-ios.js';
+import { generateWebIconsManifest, planWebIcons } from '../formats/icons-web.js';
+import {
+  ANDROID_RES_OUT,
+  ANDROID_TOKENS_OUT,
+  IOS_ICONS_ASSETS_OUT,
+  IOS_ICONS_OUT,
+  ROOT,
+  WEB_ICONS_OUT,
+  WEB_OUT,
+  logStage,
+} from './shared.js';
+
+function buildIOSIcons(tokens: IconToken[]): void {
+  // wipe and rebuild the xcasset so removed icons don't linger
+  const assetsRoot = resolve(ROOT, IOS_ICONS_ASSETS_OUT);
+  rmSync(assetsRoot, { recursive: true, force: true });
+  mkdirSync(assetsRoot, { recursive: true });
+  writeFileSync(resolve(assetsRoot, 'Contents.json'), catalogContentsJson());
+
+  const plans = planIOSImagesets(tokens);
+  for (const plan of plans) {
+    const imagesetDir = resolve(assetsRoot, `${plan.name}.imageset`);
+    mkdirSync(imagesetDir, { recursive: true });
+    const filename = `${plan.name}.svg`;
+    cpSync(
+      resolve(ROOT, ICON_DEFINITIONS_DIR, plan.variant, `${plan.iconName}.svg`),
+      resolve(imagesetDir, filename),
+    );
+    writeFileSync(resolve(imagesetDir, 'Contents.json'), imagesetContentsJson(filename));
+  }
+
+  const swiftDir = resolve(ROOT, IOS_ICONS_OUT);
+  mkdirSync(swiftDir, { recursive: true });
+  writeFileSync(resolve(swiftDir, 'NucleusIcon+Defaults.swift'), generateIOSIcons(tokens));
+
+  logStage('tokens/definitions/icons (ios)', [
+    ['ios', `${IOS_ICONS_OUT}/NucleusIcon+Defaults.swift`],
+    ['ios', `${IOS_ICONS_ASSETS_OUT} (${plans.length} imagesets)`],
+  ]);
+}
+
+function buildAndroidIcons(tokens: IconToken[]): void {
+  const drawableDir = resolve(ROOT, ANDROID_RES_OUT, 'drawable');
+  mkdirSync(drawableDir, { recursive: true });
+
+  // wipe previously-generated nucleus icons so removed icons don't linger,
+  // but leave any other drawables in this folder untouched
+  for (const file of readdirSync(drawableDir)) {
+    if (file.startsWith('nucleus_icon_')) {
+      rmSync(resolve(drawableDir, file));
+    }
+  }
+
+  let drawableCount = 0;
+  for (const token of tokens) {
+    for (const variant of token.variants) {
+      const svg = readFileSync(
+        resolve(ROOT, ICON_DEFINITIONS_DIR, variant, `${token.name}.svg`),
+        'utf8',
+      );
+      const xml = svgToVectorDrawable(svg);
+      const filename = `${androidDrawableName(token, variant)}.xml`;
+      writeFileSync(resolve(drawableDir, filename), xml);
+      drawableCount += 1;
+    }
+  }
+
+  const tokensDir = resolve(ROOT, ANDROID_TOKENS_OUT);
+  mkdirSync(tokensDir, { recursive: true });
+  writeFileSync(resolve(tokensDir, 'NucleusIcon.kt'), generateAndroidIcons(tokens));
+
+  logStage('tokens/definitions/icons (android)', [
+    ['android', `${ANDROID_TOKENS_OUT}/NucleusIcon.kt`],
+    ['android', `${ANDROID_RES_OUT}/drawable (${drawableCount} vector drawables)`],
+  ]);
+}
+
+function buildWebIcons(tokens: IconToken[]): void {
+  const outDir = resolve(ROOT, WEB_ICONS_OUT);
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  const plans = planWebIcons(tokens);
+  for (const plan of plans) {
+    for (const variant of Object.keys(plan.files) as IconVariant[]) {
+      const filename = `${iconAssetBaseName(plan.name, variant)}.svg`;
+      cpSync(
+        resolve(ROOT, ICON_DEFINITIONS_DIR, variant, `${plan.name}.svg`),
+        resolve(outDir, filename),
+      );
+    }
+  }
+
+  writeFileSync(resolve(ROOT, WEB_OUT, 'nucleus-icons.json'), generateWebIconsManifest(tokens));
+
+  logStage('tokens/definitions/icons (web)', [
+    ['web', `${WEB_OUT}/nucleus-icons.json`],
+    ['web', `${WEB_ICONS_OUT} (${plans.length} svgs)`],
+  ]);
+}
+
+export function buildIcons(): void {
+  const tokens = discoverIconTokens();
+  buildIOSIcons(tokens);
+  buildAndroidIcons(tokens);
+  buildWebIcons(tokens);
+}

package/tokens/build/index.ts

@@ -0,0 +1,29 @@
+import { buildButtons } from './buttons.js';
+import { buildColors } from './colors.js';
+import { buildFonts } from './fonts.js';
+import { buildIcons } from './icons.js';
+import { buildResolver } from './resolver.js';
+import { buildWebTypes } from './types.js';
+import { copyWebPackageTemplates } from './web-package.js';
+
+function main(): void {
+  console.log('Building Nucleus tokens…');
+
+  buildColors();
+  buildFonts();
+  buildIcons();
+  buildButtons();
+  buildWebTypes();
+  buildResolver();
+
+  console.log('\n✓ Tokens built');
+  copyWebPackageTemplates();
+  console.log('\nDone!');
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(err);
+  process.exit(1);
+}

package/tokens/build/resolver.ts

@@ -0,0 +1,72 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+import { generateAndroidResolver } from '../formats/resolver-android.js';
+import {
+  generateIOSButtonResolvable,
+  generateIOSColorResolvable,
+  generateIOSFontResolvable,
+  generateIOSIconResolvable,
+} from '../formats/resolver-ios.js';
+import { buildTokenCatalog } from '../formats/resolver-shared.js';
+import {
+  generateWebTokenPathsDts,
+  generateWebTokenPathsJs,
+} from '../formats/resolver-web.js';
+import {
+  ANDROID_TOKENS_OUT,
+  IOS_BUTTONS_OUT,
+  IOS_COLORS_OUT,
+  IOS_FONTS_OUT,
+  IOS_ICONS_OUT,
+  ROOT,
+  WEB_OUT,
+  logStage,
+} from './shared.js';
+
+function writeOut(relPath: string, content: string): void {
+  const absolute = resolve(ROOT, relPath);
+  mkdirSync(resolve(absolute, '..'), { recursive: true });
+  writeFileSync(absolute, content);
+}
+
+/**
+ * Generates the cross-platform token resolver from the same definitions that drive the static
+ * accessors: per-type iOS `TokenResolvable` conformances (each in its own target — no module that
+ * imports everything), the single-module Android `NucleusTokenResolver`, and the web `token-paths`
+ * constants the app-backend SDUI library imports instead of hand-maintaining token literals.
+ */
+export function buildResolver(): void {
+  const catalog = buildTokenCatalog();
+
+  const iosColor = `${IOS_COLORS_OUT}/NucleusColor+TokenResolvable.swift`;
+  writeOut(iosColor, generateIOSColorResolvable(catalog));
+
+  const iosFont = `${IOS_FONTS_OUT}/NucleusFont+TokenResolvable.swift`;
+  writeOut(iosFont, generateIOSFontResolvable(catalog));
+
+  const iosButton = `${IOS_BUTTONS_OUT}/NucleusButton+TokenResolvable.swift`;
+  writeOut(iosButton, generateIOSButtonResolvable(catalog));
+
+  const iosIcon = `${IOS_ICONS_OUT}/NucleusIcon+TokenResolvable.swift`;
+  writeOut(iosIcon, generateIOSIconResolvable(catalog));
+
+  const androidOut = `${ANDROID_TOKENS_OUT}/NucleusTokenResolver.kt`;
+  writeOut(androidOut, generateAndroidResolver(catalog));
+
+  const webJsOut = `${WEB_OUT}/token-paths.js`;
+  writeOut(webJsOut, generateWebTokenPathsJs(catalog));
+
+  const webDtsOut = `${WEB_OUT}/token-paths.d.ts`;
+  writeOut(webDtsOut, generateWebTokenPathsDts(catalog));
+
+  logStage('token resolver (type-scoped tokens → tokens)', [
+    ['ios', iosColor],
+    ['ios', iosFont],
+    ['ios', iosButton],
+    ['ios', iosIcon],
+    ['android', androidOut],
+    ['web', webJsOut],
+    ['web', webDtsOut],
+  ]);
+}

package/tokens/build/shared.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+export const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+export const BUILD_VERSION = readFileSync(resolve(ROOT, 'VERSION'), 'utf8').trim();
+
+export const ANDROID_TOKENS_OUT = 'android/nucleus/src/main/java/com/worldcoin/nucleus/tokens';
+export const ANDROID_RES_OUT = 'android/nucleus/src/main/res';
+export const IOS_COLORS_OUT = 'ios/Sources/NucleusColors';
+export const IOS_FONTS_OUT = 'ios/Sources/NucleusFonts';
+export const IOS_FONTS_RESOURCES_OUT = `${IOS_FONTS_OUT}/Resources/Fonts`;
+export const IOS_BUTTONS_OUT = 'ios/Sources/NucleusButtons';
+export const IOS_ICONS_OUT = 'ios/Sources/NucleusIcons';
+export const IOS_ICONS_ASSETS_OUT = `${IOS_ICONS_OUT}/Resources/Icons.xcassets`;
+export const WEB_OUT = 'build/web';
+export const WEB_FONTS_OUT = `${WEB_OUT}/fonts`;
+export const WEB_ICONS_OUT = `${WEB_OUT}/icons`;
+
+export function logStage(header: string, files: ReadonlyArray<readonly [string, string]>): void {
+  console.log(`\n${header}`);
+  for (const [platform, output] of files) {
+    console.log(`  ${platform.padEnd(8)}✔︎ ${output}`);
+  }
+}