@multiplatform.one/config 7.34.3 → 7.35.0

package/README.md

@@ -127,3 +127,51 @@ runConventionChecks({
   roots: { root: process.cwd() },
 });
 ```
+
+### MPO design guard
+
+`pnpm exec mpo-design-lint` checks application source in any repo. With no
+paths it scans whichever of `apps`, `features` and `packages` exist; pass
+directories or source files to change that. It rejects raw controls, `styled()`
+wrappers around MPO components, numeric geometry, inline spacing styles, hex
+colours and local token files (`tokens.ts`, `design-tokens.ts`, or any call to
+`createTokens`, `createTamagui`, `createTheme(s)` or `createFont`). Tokens and
+shared recipes stay in MPO. Numeric geometry on SVG primitives (`Rect`,
+`Path`, `G` and the rest from `react-native-svg` or `@tamagui/react-native-svg`,
+or lowercase DOM SVG elements) is artwork, not layout, and is not reported when
+the enclosing `Svg` has a `viewBox`, including one passed through a spread, or
+when the mark is a fragment drawn into an `Svg` elsewhere. Primitives inside an
+`Svg` with no `viewBox`, and the `Svg` element's own size, are still reported.
+
+Every violation is tagged with its rule: `hex`, `geometry`, `inline-spacing`,
+`raw-control`, `styled-mpo` or `token-file`.
+
+#### Ratchet
+
+```sh
+pnpm exec mpo-design-lint --baseline design-baseline.json --init   # once, commit the file
+pnpm exec mpo-design-lint --baseline design-baseline.json          # lint step
+pnpm exec mpo-design-lint --baseline design-baseline.json --frozen # CI
+```
+
+The baseline records the scanned paths (relative to the baseline file) and a
+count per rule. A run fails when any rule's count rises above the baseline, and
+a drop in one rule never pays for a rise in another. When counts only fall, the
+run rewrites the baseline down and exits 0; commit it. `--frozen` fails that
+case instead, so CI catches a lowered count nobody committed. `--list` prints
+the violations on a passing run. `--baseline` may repeat; MPO's `pnpm
+lint:design` ratchets `apps/one` and `apps/storybook-expo` this way.
+
+The implementation is also exported from `@multiplatform.one/config/design-lint`
+as `inspectDesign(source, filename)`, `designFiles(path)` and `runDesignLint(paths)`.
+It derives from Pelt's `db7ce75c` guard. TypeScript ships as a runtime dependency.
+Tests, stories, generated files, vendor/build trees and `public/` primitives are
+excluded from discovery. A missing path or empty scan fails. Existing
+`hex-escape: <reason>` file declarations only exempt hex literals, for surfaces
+without a theme runtime. They do not exempt geometry or controls.
+
+The guard resolves file-local aliases and spreads; it does not resolve imported
+style objects or prove the absence of arbitrary runtime styling. Review remains
+required by LC-109. MPO ratchets `apps/one` and `apps/storybook-expo` against
+committed baselines; consumer repos should include their feature and integration
+source paths too.

package/design-lint.mjs

@@ -0,0 +1,524 @@
+#!/usr/bin/env node
+import ts from "typescript";
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  realpathSync,
+  writeFileSync,
+} from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const layout =
+  /^(?:padding|margin)(?:Top|Right|Bottom|Left|Horizontal|Vertical|Start|End|Inline(?:Start|End)?|Block(?:Start|End)?)?$|^(?:(?:min|max)?(?:Width|Height)|width|height|size|fontSize|gap|rowGap|columnGap|p|px|py|pt|pr|pb|pl|m|mx|my|mt|mr|mb|ml|w|h|borderRadius|borderTopLeftRadius|borderTopRightRadius|borderBottomLeftRadius|borderBottomRightRadius)$/;
+const raw = new Set([
+  "Pressable",
+  "TouchableOpacity",
+  "TouchableHighlight",
+  "TouchableWithoutFeedback",
+  "TextInput",
+  "button",
+  "input",
+  "select",
+  "textarea",
+]);
+const controls = new Set([...raw, "Button", "Input", "TamaguiButton"]);
+const svgPrimitives = new Set([
+  "Circle",
+  "ClipPath",
+  "Defs",
+  "Ellipse",
+  "ForeignObject",
+  "G",
+  "Image",
+  "Line",
+  "LinearGradient",
+  "Marker",
+  "Mask",
+  "Path",
+  "Pattern",
+  "Polygon",
+  "Polyline",
+  "RadialGradient",
+  "Rect",
+  "Stop",
+  "Symbol",
+  "Text",
+  "TextPath",
+  "TSpan",
+  "Use",
+]);
+const svgRoots = new Set(["Svg", "Symbol"]);
+const tokenFactories = new Set([
+  "createTokens",
+  "createTamagui",
+  "createTheme",
+  "createThemes",
+  "createFont",
+]);
+export const designRules = [
+  "hex",
+  "geometry",
+  "inline-spacing",
+  "raw-control",
+  "styled-mpo",
+  "token-file",
+];
+export function inspectDesign(source, filename) {
+  const file = ts.createSourceFile(
+    filename,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX,
+  );
+  const options = {
+    noLib: true,
+    noResolve: true,
+    types: [],
+    jsx: ts.JsxEmit.Preserve,
+  };
+  const host = ts.createCompilerHost(options);
+  host.getSourceFile = (requested) => (requested === filename ? file : undefined);
+  host.fileExists = (requested) => requested === filename;
+  host.readFile = (requested) => (requested === filename ? source : undefined);
+  host.directoryExists = () => false;
+  const checker = ts.createProgram([filename], options, host).getTypeChecker();
+  const errors = [];
+  function importedFrom(node, test) {
+    const value = resolve(node);
+    const root = ts.isPropertyAccessExpression(value) ? value.expression : value;
+    const declarations = checker.getSymbolAtLocation(root)?.declarations ?? [];
+    return declarations.some((declaration) => {
+      let current = declaration;
+      while (current && !ts.isImportDeclaration(current)) current = current.parent;
+      return current && test(current.moduleSpecifier.text);
+    });
+  }
+  const mpoComponent = (node) =>
+    importedFrom(node, (specifier) => specifier.startsWith("@multiplatform.one/"));
+  const fromSvg = (node) =>
+    importedFrom(node, (specifier) => /^(?:@tamagui\/)?react-native-svg$/.test(specifier));
+  function svgTag(tag, set) {
+    if (ts.isIdentifier(tag) && /^[a-z]/.test(tag.text))
+      return set.has(tag.text[0].toUpperCase() + tag.text.slice(1));
+    return set.has(referenceName(tag)) && fromSvg(tag);
+  }
+  function carriesViewBox(node) {
+    const value = resolve(node);
+    if (!ts.isObjectLiteralExpression(value)) return true;
+    return value.properties.some((prop) =>
+      ts.isSpreadAssignment(prop)
+        ? carriesViewBox(prop.expression)
+        : !!prop.name && name(prop.name) === "viewBox",
+    );
+  }
+  function hasViewBox(element) {
+    return element.attributes.properties.some((attribute) =>
+      ts.isJsxSpreadAttribute(attribute)
+        ? carriesViewBox(attribute.expression)
+        : name(attribute.name) === "viewBox",
+    );
+  }
+  function svgArtwork(element) {
+    if (!svgTag(element.tagName, svgPrimitives)) return false;
+    for (let current = element.parent; current; current = current.parent) {
+      const opening = ts.isJsxElement(current) ? current.openingElement : undefined;
+      if (opening && opening !== element && svgTag(opening.tagName, svgRoots))
+        return hasViewBox(opening);
+    }
+    return true;
+  }
+  function name(node) {
+    return ts.isPropertyAccessExpression(node)
+      ? node.name.text
+      : node.getText(file).replace(/["']/g, "");
+  }
+  function resolve(node, seen = new Set()) {
+    if (
+      ts.isParenthesizedExpression(node) ||
+      ts.isAsExpression(node) ||
+      ts.isSatisfiesExpression(node)
+    )
+      return resolve(node.expression, seen);
+    const declaration = ts.isIdentifier(node)
+      ? checker.getSymbolAtLocation(node)?.valueDeclaration
+      : undefined;
+    if (
+      declaration &&
+      ts.isVariableDeclaration(declaration) &&
+      declaration.initializer &&
+      !seen.has(declaration)
+    ) {
+      seen.add(declaration);
+      return resolve(declaration.initializer, seen);
+    }
+    return node;
+  }
+  function numeric(node) {
+    const value = resolve(node);
+    if (ts.isNumericLiteral(value)) return true;
+    if (ts.isStringLiteral(value)) return /^-?\d+(?:\.\d+)?(?:px|rem|em)?$/.test(value.text);
+    if (ts.isPrefixUnaryExpression(value)) return numeric(value.operand);
+    if (ts.isBinaryExpression(value)) {
+      if (
+        [
+          ts.SyntaxKind.AmpersandAmpersandToken,
+          ts.SyntaxKind.BarBarToken,
+          ts.SyntaxKind.QuestionQuestionToken,
+        ].includes(value.operatorToken.kind)
+      )
+        return numeric(value.left) || numeric(value.right);
+      return numeric(value.left) && numeric(value.right);
+    }
+    if (ts.isConditionalExpression(value))
+      return numeric(value.whenTrue) || numeric(value.whenFalse);
+    return false;
+  }
+  function referenceName(node) {
+    const value = resolve(node);
+    const declaration = ts.isIdentifier(value)
+      ? checker.getSymbolAtLocation(value)?.declarations?.[0]
+      : undefined;
+    if (declaration && ts.isImportSpecifier(declaration))
+      return (declaration.propertyName ?? declaration.name).text;
+    return name(value);
+  }
+  function spacing(node) {
+    const value = resolve(node);
+    if (ts.isArrayLiteralExpression(value)) return value.elements.some((item) => spacing(item));
+    if (ts.isObjectLiteralExpression(value))
+      return value.properties.some((prop) => {
+        if (ts.isSpreadAssignment(prop)) return spacing(prop.expression);
+        return (
+          !!prop.name &&
+          layout.test(name(prop.name)) &&
+          !["fontSize", "size"].includes(name(prop.name))
+        );
+      });
+    if (ts.isBinaryExpression(value)) return spacing(value.left) || spacing(value.right);
+    if (ts.isConditionalExpression(value))
+      return spacing(value.whenTrue) || spacing(value.whenFalse);
+    return false;
+  }
+  function report(node, rule, message) {
+    const { line, character } = file.getLineAndCharacterOfPosition(node.getStart(file));
+    errors.push(`${filename}:${line + 1}:${character + 1}: [${rule}] ${message}`);
+  }
+  let tokenFile = false;
+  if (/^(?:design-)?tokens\.[cm]?[jt]sx?$/.test(path.basename(filename))) {
+    tokenFile = true;
+    report(file, "token-file", "Local token files are forbidden; tokens live in MPO.");
+  }
+  function inspectProps(node, seen = new Set(), deep = false) {
+    const value = resolve(node);
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (ts.isArrayLiteralExpression(value))
+      value.elements.forEach((item) => inspectProps(item, seen, deep));
+    if (ts.isConditionalExpression(value)) {
+      inspectProps(value.whenTrue, seen, deep);
+      inspectProps(value.whenFalse, seen, deep);
+    }
+    if (ts.isBinaryExpression(value)) {
+      if (
+        value.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+        value.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken
+      )
+        inspectProps(value.left, seen, deep);
+      inspectProps(value.right, seen, deep);
+    }
+    if (ts.isObjectLiteralExpression(value))
+      value.properties.forEach((prop) => {
+        if (ts.isSpreadAssignment(prop)) inspectProps(prop.expression, seen, deep);
+        if (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) {
+          const initializer = ts.isShorthandPropertyAssignment(prop)
+            ? checker.getShorthandAssignmentValueSymbol(prop)?.valueDeclaration?.initializer
+            : prop.initializer;
+          if (!initializer) return;
+          const key = name(prop.name);
+          if (layout.test(key) && numeric(initializer))
+            report(prop, "geometry", `${name(prop.name)} requires a token, not a numeric literal.`);
+          if (/style$/i.test(key) && spacing(initializer))
+            report(prop, "inline-spacing", "Inline spacing styles are forbidden; use token props.");
+          if (deep || key.startsWith("$") || /style$/i.test(key))
+            inspectProps(initializer, seen, deep);
+        }
+      });
+  }
+  function visit(node) {
+    if (
+      !tokenFile &&
+      ts.isCallExpression(node) &&
+      tokenFactories.has(referenceName(node.expression))
+    ) {
+      tokenFile = true;
+      report(node, "token-file", "Local token files are forbidden; tokens live in MPO.");
+    }
+    if (
+      (ts.isStringLiteralLike(node) ||
+        ts.isTemplateHead(node) ||
+        ts.isTemplateMiddle(node) ||
+        ts.isTemplateTail(node)) &&
+      /#[\da-fA-F]{3,8}\b/.test(node.text) &&
+      !/^\s*\/\/ hex-escape: \S.+$/m.test(source)
+    ) {
+      report(node, "hex", "Hex colours require a theme token.");
+    }
+    if (
+      ts.isCallExpression(node) &&
+      referenceName(node.expression) === "styled" &&
+      node.arguments[0] &&
+      (controls.has(referenceName(node.arguments[0])) || mpoComponent(node.arguments[0]))
+    ) {
+      report(
+        node,
+        "styled-mpo",
+        "Use the MPO component directly; styled MPO wrappers are forbidden.",
+      );
+    }
+    if (
+      ts.isCallExpression(node) &&
+      (referenceName(node.expression) === "styled" ||
+        node.expression.getText(file) === "StyleSheet.create")
+    )
+      node.arguments
+        .slice(referenceName(node.expression) === "styled" ? 1 : 0)
+        .forEach((arg) => inspectProps(arg, new Set(), true));
+    if (
+      ts.isCallExpression(node) &&
+      referenceName(node.expression) === "createElement" &&
+      node.arguments[0] &&
+      raw.has(referenceName(node.arguments[0]))
+    )
+      report(node, "raw-control", "Use an MPO control instead of a raw control.");
+    if (
+      ts.isCallExpression(node) &&
+      referenceName(node.expression) === "createElement" &&
+      node.arguments[1]
+    )
+      inspectProps(node.arguments[1]);
+    if (ts.isJsxSpreadAttribute(node) && !svgArtwork(node.parent.parent))
+      inspectProps(node.expression);
+    if (
+      (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) &&
+      raw.has(referenceName(node.tagName))
+    ) {
+      report(node, "raw-control", "Use an MPO control instead of a raw control.");
+    }
+    if (ts.isJsxAttribute(node) && node.initializer) {
+      const key = name(node.name);
+      const value = ts.isJsxExpression(node.initializer)
+        ? node.initializer.expression
+        : node.initializer;
+      if (value && (key.startsWith("$") || /style$/i.test(key))) inspectProps(value);
+      if (value && layout.test(key) && numeric(value) && !svgArtwork(node.parent.parent))
+        report(node, "geometry", `${key} requires a token, not a numeric literal.`);
+      if (value && /style$/i.test(key) && spacing(value))
+        report(node, "inline-spacing", "Inline spacing styles are forbidden; use token props.");
+      if (
+        value &&
+        ["render", "as", "tag"].includes(key) &&
+        ts.isStringLiteral(value) &&
+        raw.has(value.text)
+      )
+        report(node, "raw-control", "Use an MPO control instead of a raw control tag.");
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(file);
+  return errors;
+}
+
+const ignoredDirectories = new Set([
+  "node_modules",
+  "public",
+  "dist",
+  "build",
+  "bundle",
+  "coverage",
+  "vendor",
+  "ios",
+  "android",
+  "tests",
+  "__tests__",
+  "__fixtures__",
+  "scripts",
+]);
+
+export function designFiles(input) {
+  const root = path.resolve(input);
+  const info = statSync(root);
+  const eligible = (filename) =>
+    /\.[cm]?[jt]sx?$/.test(filename) &&
+    !/\.(?:test|spec|stories|config|gen|generated|d)\.[cm]?[jt]sx?$/.test(filename);
+  if (info.isFile()) return eligible(root) ? [root] : [];
+  let candidates;
+  try {
+    candidates = execFileSync(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard", "-z", "--", "."],
+      {
+        cwd: root,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      },
+    )
+      .split("\0")
+      .filter(Boolean);
+  } catch {
+    candidates = [];
+    function walk(dir) {
+      for (const entry of readdirSync(path.join(root, dir), { withFileTypes: true })) {
+        if (entry.name.startsWith(".") || ignoredDirectories.has(entry.name)) continue;
+        const relative = path.join(dir, entry.name);
+        if (entry.isDirectory()) walk(relative);
+        else if (entry.isFile()) candidates.push(relative);
+      }
+    }
+    walk("");
+  }
+  return [...new Set(candidates)]
+    .filter(
+      (filename) =>
+        eligible(filename) &&
+        !filename
+          .split(path.sep)
+          .some((part) => part.startsWith(".") || ignoredDirectories.has(part)),
+    )
+    .map((filename) => path.join(root, filename))
+    .filter((filename) => {
+      try {
+        return statSync(filename).isFile();
+      } catch {
+        return false;
+      }
+    })
+    .sort();
+}
+
+export const defaultScope = ["apps", "features", "packages"];
+
+const ruleOf = (error) => /: \[([a-z-]+)\] /.exec(error)?.[1] ?? "unknown";
+
+export function countDesign(errors) {
+  const rules = Object.fromEntries(designRules.map((rule) => [rule, 0]));
+  for (const error of errors) rules[ruleOf(error)] = (rules[ruleOf(error)] ?? 0) + 1;
+  return { total: errors.length, rules };
+}
+
+export function scanDesign(paths) {
+  const files = [...new Set(paths.flatMap(designFiles))];
+  if (!files.length) throw new Error("No application source files found in the supplied paths.");
+  const errors = files.flatMap((filename) =>
+    inspectDesign(readFileSync(filename, "utf8"), filename),
+  );
+  return { files, errors, ...countDesign(errors) };
+}
+
+function parseArgs(args) {
+  const options = { paths: [], baselines: [], frozen: false, init: false, list: false };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--baseline") {
+      if (!args[index + 1]) throw new Error("--baseline needs a file.");
+      options.baselines.push(args[++index]);
+    } else if (arg === "--frozen") options.frozen = true;
+    else if (arg === "--init") options.init = true;
+    else if (arg === "--list") options.list = true;
+    else if (arg.startsWith("--")) throw new Error(`Unknown option ${arg}.`);
+    else options.paths.push(arg);
+  }
+  if (options.paths.length && options.baselines.length > 1)
+    throw new Error("Pass paths with at most one --baseline.");
+  return options;
+}
+
+function summary(scan) {
+  const rules = Object.entries(scan.rules)
+    .filter(([, count]) => count)
+    .map(([rule, count]) => `${rule} ${count}`)
+    .join(", ");
+  return `${scan.total} violations in ${scan.files.length} files${rules ? ` (${rules})` : ""}`;
+}
+
+function scopeFrom(base) {
+  const scope = defaultScope.filter((dir) => existsSync(path.join(base, dir)));
+  if (!scope.length)
+    throw new Error(`No ${defaultScope.join(", ")} directory under ${base}; pass paths.`);
+  return scope;
+}
+
+function ratchet(file, options) {
+  const real = (input) => (existsSync(input) ? realpathSync(input) : path.resolve(input));
+  const base = real(path.dirname(path.resolve(file)));
+  const relative = (input) => path.relative(base, real(input)) || ".";
+  const present = existsSync(file);
+  if (!present && !options.init)
+    throw new Error(`${file} does not exist; create it with --init and commit it.`);
+  const previous = present ? JSON.parse(readFileSync(file, "utf8")) : undefined;
+  const paths = options.paths.length
+    ? options.paths.map(relative)
+    : (previous?.paths ?? scopeFrom(process.cwd()).map(relative));
+  const scan = scanDesign(paths.map((input) => path.resolve(base, input)));
+  const next = {
+    paths,
+    total: scan.total,
+    rules: Object.fromEntries(Object.entries(scan.rules).sort()),
+  };
+  const write = () => writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
+  if (!previous) {
+    write();
+    process.stdout.write(`MPO design guard: ${file} created at ${summary(scan)}.\n`);
+    return 0;
+  }
+  const rules = [...new Set([...Object.keys(previous.rules ?? {}), ...Object.keys(next.rules)])];
+  const rose = rules.filter((rule) => (next.rules[rule] ?? 0) > (previous.rules?.[rule] ?? 0));
+  const fell = rules.filter((rule) => (next.rules[rule] ?? 0) < (previous.rules?.[rule] ?? 0));
+  if (rose.length) {
+    process.stderr.write(
+      `${scan.errors.join("\n")}\nMPO design guard: ${file} regressed, ${rose
+        .map((rule) => `${rule} ${previous.rules?.[rule] ?? 0} -> ${next.rules[rule]}`)
+        .join(", ")}. ${summary(scan)}.\n`,
+    );
+    return 1;
+  }
+  if (options.list && scan.errors.length) process.stderr.write(`${scan.errors.join("\n")}\n`);
+  if (fell.length) {
+    const change = `${previous.total} -> ${next.total}`;
+    if (options.frozen) {
+      process.stderr.write(
+        `MPO design guard: ${file} is stale (${change}); run the lint without --frozen and commit the lowered baseline.\n`,
+      );
+      return 1;
+    }
+    write();
+    process.stdout.write(`MPO design guard: ${file} ratcheted down ${change}. ${summary(scan)}.\n`);
+    return 0;
+  }
+  process.stdout.write(`MPO design guard: ${file} holds at ${summary(scan)}.\n`);
+  return 0;
+}
+
+export function runDesignLint(args = process.argv.slice(2)) {
+  try {
+    const options = parseArgs(args);
+    if (options.baselines.length)
+      return options.baselines.reduce((status, file) => ratchet(file, options) || status, 0);
+    const scan = scanDesign(options.paths.length ? options.paths : scopeFrom(process.cwd()));
+    if (scan.errors.length) {
+      process.stderr.write(`${scan.errors.join("\n")}\nMPO design guard: ${summary(scan)}.\n`);
+      return 1;
+    }
+    process.stdout.write(`MPO design guard passed (${scan.files.length} source files).\n`);
+    return 0;
+  } catch (error) {
+    process.stderr.write(`MPO design guard: ${error.message}\n`);
+    return 1;
+  }
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url))
+  process.exitCode = runDesignLint();

package/lib/index.js

@@ -1,6 +1,6 @@
-import { t as createViteConfig } from "./vite-n3XSaftn.js";
-import { i as phosphorTokenColorPlugin, n as tamaguiWorkspacePathsFile, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-B6aRC2BU.js";
-import { t as createStorybookViteConfig } from "./storybook-Dxwh_fl2.js";
+import { t as createViteConfig } from "./vite-DkidIRYX.js";
+import { i as phosphorTokenColorPlugin, n as tamaguiWorkspacePathsFile, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-DR3dud79.js";
+import { t as createStorybookViteConfig } from "./storybook-Ba0KCHBo.js";
 import { createVitestConfig } from "./vitest.js";
 
 export { createStorybookViteConfig, createViteConfig, createVitestConfig, ensureTamaguiWorkspacePaths, phosphorTokenColorPlugin, tamaguiWorkspacePathsFile };

package/lib/{storybook-Dxwh_fl2.js → storybook-Ba0KCHBo.js}

@@ -1,4 +1,4 @@
-import { i as phosphorTokenColorPlugin, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-B6aRC2BU.js";
+import { i as phosphorTokenColorPlugin, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-DR3dud79.js";
 import { i as withSingletonDepAliases, r as resolvePackageMainSource, t as discoverPublicPackageRoots } from "./workspacePublicPackages-ClSmVngx.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -246,11 +246,18 @@ function mergePackageResolveAliases(pkgDir, pkgName, pkgJson, aliases) {
 				if (fs.existsSync(fullParentDir) && fs.statSync(fullParentDir).isDirectory()) aliases[`${pkgName}/${parentDir}`] = fullParentDir;
 			}
 		} else {
-			const resolved = resolveSubpathSource(pkgDir, subpath);
+			const resolved = resolveSubpathSource(pkgDir, subpath) ?? exportSourceTarget(pkgDir, pkgJson.exports[exportKey]);
 			if (resolved) aliases[`${pkgName}/${subpath}`] = resolved;
 		}
 	}
 }
+/** An export entry's `source` file, for subpaths whose name is not their path under src/. */
+function exportSourceTarget(pkgDir, entry) {
+	const source = entry?.source;
+	if (typeof source !== "string") return void 0;
+	const file = path.join(pkgDir, source);
+	return fs.existsSync(file) && fs.statSync(file).isFile() ? file : void 0;
+}
 function resolveSubpathSource(pkgDir, subpath) {
 	const candidates = [
 		path.join(pkgDir, "src", `${subpath}.storybook.ts`),

package/lib/storybook.js

@@ -1,3 +1,3 @@
-import { t as createStorybookViteConfig } from "./storybook-Dxwh_fl2.js";
+import { t as createStorybookViteConfig } from "./storybook-Ba0KCHBo.js";
 
 export { createStorybookViteConfig };

package/lib/{tamaguiWorkspacePaths-B6aRC2BU.js → tamaguiWorkspacePaths-DR3dud79.js}

@@ -6,6 +6,7 @@ import { execFileSync } from "node:child_process";
 
 //#region src/phosphorTokenColor.ts
 const virtualPrefix = "\0mpo-phosphor-token-icon-base:";
+const virtualSuffix = "?mpo-token-icon";
 const iconBaseFilter = /IconBase\.es\.js$/;
 const phosphorLibFile = /\/@phosphor-icons\/react\/dist\/lib\/IconBase\.es\.js$/;
 const phosphorBarrelFile = /\/@phosphor-icons\/react\/dist\/index\.es\.js$/;
@@ -57,10 +58,10 @@ function resolvePhosphorIconBase(id, importer) {
 	if (!importer || importer.startsWith("\0")) return null;
 	if (!toPosix(importer).includes("/@phosphor-icons/react/dist/")) return null;
 	const target = toPosix(id.startsWith(".") ? path.resolve(path.dirname(importer), id) : id);
-	return phosphorLibFile.test(target) ? virtualPrefix + target : null;
+	return phosphorLibFile.test(target) ? virtualPrefix + target + virtualSuffix : null;
 }
 function loadTokenColorIconBase(id) {
-	return id.startsWith(virtualPrefix) ? tokenColorIconBaseSource(id.slice(30)) : null;
+	return id.startsWith(virtualPrefix) ? tokenColorIconBaseSource(id.slice(30, -15)) : null;
 }
 function rolldownTokenColorPlugin() {
 	return {

package/lib/{vite-n3XSaftn.js → vite-DkidIRYX.js}

@@ -1,4 +1,4 @@
-import { i as phosphorTokenColorPlugin, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-B6aRC2BU.js";
+import { i as phosphorTokenColorPlugin, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-DR3dud79.js";
 import { i as withSingletonDepAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-ClSmVngx.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";

package/lib/vite.js

@@ -1,5 +1,5 @@
-import { n as publicConfigPlugin, r as readPublicConfigKeys, t as createViteConfig } from "./vite-n3XSaftn.js";
-import { i as phosphorTokenColorPlugin } from "./tamaguiWorkspacePaths-B6aRC2BU.js";
+import { n as publicConfigPlugin, r as readPublicConfigKeys, t as createViteConfig } from "./vite-DkidIRYX.js";
+import { i as phosphorTokenColorPlugin } from "./tamaguiWorkspacePaths-DR3dud79.js";
 import { n as publicPackageViteSourceAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-ClSmVngx.js";
 
 export { createViteConfig, discoverPublicPackageRoots, phosphorTokenColorPlugin, publicConfigPlugin, publicPackageViteSourceAliases, readPublicConfigKeys };

package/lib/vitest.js

@@ -1,4 +1,4 @@
-import { i as phosphorTokenColorPlugin, r as phosphorBarrelBundlePlugin, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-B6aRC2BU.js";
+import { i as phosphorTokenColorPlugin, r as phosphorBarrelBundlePlugin, t as ensureTamaguiWorkspacePaths } from "./tamaguiWorkspacePaths-DR3dud79.js";
 import Module from "node:module";
 import fs from "node:fs";
 import path from "node:path";