@sequenceholdings/artifact-studio 0.2.1 → 0.2.3

package/dist/token-contract.js

@@ -0,0 +1,245 @@
+import ts from 'typescript';
+const RETIRED_OPACITY_UTILITY = /(?:^|\s)((?:[^\s"'`]+:)*(?:bg|text|border(?:-[trblxy])?|ring(?:-offset)?|fill|stroke|outline|divide(?:-[xy])?|decoration|accent|caret|shadow)-(?:black|white)-\d+(?:\/[^\s"'`]+)?!?)(?=$|\s)/g;
+const DEPRECATED_TOKEN_IMPORT = /@import\s+(?:url\(\s*)?(?:["'][^"']*@sequenceholdings\/atlas-ui\/|[^"'()\s;]*@sequenceholdings\/atlas-ui\/)(tokens\.v2\.css|theme\.v2\.css)(?:["'])?\s*\)?[^;\n]*;/gi;
+export function collectDeprecatedTokenImportDiagnostics({ files, }) {
+    const diagnostics = [];
+    for (const file of files) {
+        if (!file.path.endsWith('.css'))
+            continue;
+        const deprecatedImports = new Set([...file.content.matchAll(DEPRECATED_TOKEN_IMPORT)].map((match) => match[1].toLowerCase()));
+        if (deprecatedImports.size === 0)
+            continue;
+        diagnostics.push(`${file.path} imports deprecated ${[...deprecatedImports].join(', ')}; ` +
+            'the compiler normalized it to @sequenceholdings/atlas-ui/tokens.css. Update the source import.');
+    }
+    return diagnostics;
+}
+/**
+ * Candidate builds use a source report rather than a build-time ban. A normal
+ * CLI release must remain able to rebuild pre-cutover artifacts; an explicit
+ * `artifact dev --link <atlas-ui>` preview is the opt-in migration surface.
+ */
+export function collectCandidateTokenCompatibilityDiagnostics({ files, }) {
+    const references = [];
+    const uncertainFiles = new Set();
+    for (const file of files) {
+        const analysis = classBearingUtilities({ file });
+        for (const utility of analysis.utilities)
+            references.push({ path: file.path, utility });
+        if (analysis.uncertain)
+            uncertainFiles.add(file.path);
+    }
+    if (references.length === 0 && uncertainFiles.size === 0)
+        return [];
+    const diagnostics = [
+        'Artifact candidate compatibility report (DES-437): canonical tokens omit numbered black/white opacity utilities.',
+    ];
+    for (const { path, utility } of references) {
+        diagnostics.push(`${path}: ${utility} is unavailable in canonical tokens; replace it with the semantic role for the element's purpose.`);
+    }
+    for (const path of uncertainFiles) {
+        diagnostics.push(`${path}: dynamic class construction could not be proven compatible; inspect it for numbered black/white opacity utilities before cutover.`);
+    }
+    return diagnostics;
+}
+function classBearingUtilities({ file }) {
+    if (file.path.endsWith('.css'))
+        return utilitiesInCss({ content: file.content });
+    if (file.path.endsWith('.html'))
+        return utilitiesInHtml({ content: file.content });
+    if (/\.[jt]sx?$/.test(file.path))
+        return utilitiesInScript({ content: file.content, path: file.path });
+    return { utilities: [], uncertain: false };
+}
+function utilitiesInCss({ content }) {
+    const utilities = [];
+    const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, '');
+    for (const apply of withoutComments.matchAll(/@apply\s+([^;]+);/g)) {
+        utilities.push(...retiredUtilitiesInClassText({ content: apply[1] }));
+    }
+    return { utilities, uncertain: false };
+}
+function utilitiesInHtml({ content }) {
+    const utilities = [];
+    for (const attribute of content.matchAll(/\bclass\s*=\s*(["'])([\s\S]*?)\1/gi)) {
+        utilities.push(...retiredUtilitiesInClassText({ content: attribute[2] }));
+    }
+    return { utilities, uncertain: false };
+}
+function utilitiesInScript({ content, path }) {
+    const scriptKind = path.endsWith('.tsx')
+        ? ts.ScriptKind.TSX
+        : path.endsWith('.jsx')
+            ? ts.ScriptKind.JSX
+            : ts.ScriptKind.TS;
+    const source = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true, scriptKind);
+    const bindings = new Map();
+    const functions = new Map();
+    const duplicateBindingNames = new Set();
+    const duplicateFunctionNames = new Set();
+    const utilities = [];
+    let uncertain = false;
+    const collectBindings = (node) => {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            if (bindings.has(node.name.text)) {
+                duplicateBindingNames.add(node.name.text);
+            }
+            else {
+                bindings.set(node.name.text, node.initializer);
+            }
+        }
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            if (functions.has(node.name.text)) {
+                duplicateFunctionNames.add(node.name.text);
+            }
+            else {
+                functions.set(node.name.text, node);
+            }
+        }
+        ts.forEachChild(node, collectBindings);
+    };
+    collectBindings(source);
+    const ambiguousNames = new Set([
+        ...duplicateBindingNames,
+        ...duplicateFunctionNames,
+        ...[...bindings.keys()].filter((name) => functions.has(name)),
+    ]);
+    const collectExpression = (node, seen = new Set()) => {
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+            utilities.push(...retiredUtilitiesInClassText({ content: node.text }));
+            return;
+        }
+        if (ts.isTemplateExpression(node)) {
+            utilities.push(...retiredUtilitiesInClassText({ content: node.head.text }));
+            for (const span of node.templateSpans) {
+                collectExpression(span.expression, seen);
+                utilities.push(...retiredUtilitiesInClassText({ content: span.literal.text }));
+            }
+            uncertain = true;
+            return;
+        }
+        if (ts.isJsxExpression(node)) {
+            if (node.expression)
+                collectExpression(node.expression, seen);
+            return;
+        }
+        if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+            collectExpression(node.expression, seen);
+            return;
+        }
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+            collectExpression(node.left, seen);
+            collectExpression(node.right, seen);
+            return;
+        }
+        if (ts.isConditionalExpression(node)) {
+            collectExpression(node.whenTrue, seen);
+            collectExpression(node.whenFalse, seen);
+            return;
+        }
+        if (ts.isIdentifier(node)) {
+            // This lightweight preview analyzer does not construct lexical scopes.
+            // Never pick one same-named binding arbitrarily: a later declaration in
+            // another scope could mask a retired utility in the binding actually used.
+            if (ambiguousNames.has(node.text)) {
+                uncertain = true;
+                return;
+            }
+            const initializer = bindings.get(node.text);
+            if (initializer) {
+                collectExpression(initializer, seen);
+            }
+            else {
+                uncertain = true;
+            }
+            return;
+        }
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+            if (ambiguousNames.has(node.expression.text)) {
+                uncertain = true;
+                return;
+            }
+            const object = bindings.get(node.expression.text);
+            if (object && ts.isObjectLiteralExpression(object)) {
+                const property = object.properties.find((candidate) => ts.isPropertyAssignment(candidate) && candidate.name.getText(source) === node.name.text);
+                if (property && ts.isPropertyAssignment(property)) {
+                    collectExpression(property.initializer, seen);
+                    return;
+                }
+            }
+            uncertain = true;
+            return;
+        }
+        if (ts.isCallExpression(node)) {
+            const name = ts.isIdentifier(node.expression) ? node.expression.text : undefined;
+            if (name && ambiguousNames.has(name)) {
+                uncertain = true;
+                return;
+            }
+            const declaration = name
+                ? functions.get(name) ?? functionFromBinding({ binding: bindings.get(name) })
+                : undefined;
+            if (declaration) {
+                // Function helpers can be recursive (directly or through another
+                // helper). This is a preview report, so treat an unbounded expansion
+                // as uncertain instead of recursing until the compiler crashes.
+                if (seen.has(declaration)) {
+                    uncertain = true;
+                    return;
+                }
+                seen.add(declaration);
+                collectFunctionReturn({ declaration, collectExpression, seen });
+                return;
+            }
+            for (const argument of node.arguments)
+                collectExpression(argument, seen);
+            uncertain = true;
+            return;
+        }
+        uncertain = true;
+    };
+    const visit = (node) => {
+        if (ts.isJsxAttribute(node) &&
+            (node.name.getText(source) === 'class' || node.name.getText(source) === 'className')) {
+            if (node.initializer)
+                collectExpression(node.initializer);
+            return;
+        }
+        if (ts.isPropertyAssignment(node) &&
+            (node.name.getText(source) === 'class' || node.name.getText(source) === 'className')) {
+            collectExpression(node.initializer);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(source, visit);
+    return { utilities, uncertain };
+}
+function functionFromBinding({ binding }) {
+    return binding && (ts.isArrowFunction(binding) || ts.isFunctionExpression(binding)) ? binding : undefined;
+}
+function collectFunctionReturn({ declaration, collectExpression, seen, }) {
+    if (!declaration.body)
+        return;
+    if (!ts.isBlock(declaration.body)) {
+        collectExpression(declaration.body, seen);
+        return;
+    }
+    const visit = (node) => {
+        if (ts.isReturnStatement(node) && node.expression)
+            collectExpression(node.expression, seen);
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(declaration.body, visit);
+}
+function retiredUtilitiesInClassText({ content }) {
+    const utilities = [];
+    for (const match of content.matchAll(RETIRED_OPACITY_UTILITY)) {
+        if (match[1])
+            utilities.push(match[1]);
+    }
+    return utilities;
+}

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "SDK types and CLI library for building Artifact Studio apps. Driven via `seq-studio artifact <sub>` (@sequenceholdings/studio-cli), which runs the `./cli` runCli export.",
   "type": "module",
   "exports": {
@@ -57,6 +57,10 @@
       "types": "./dist/active-deploy-policy.d.ts",
       "default": "./dist/active-deploy-policy.js"
     },
+    "./reporting-limits": {
+      "types": "./dist/reporting-limits.d.ts",
+      "default": "./dist/reporting-limits.js"
+    },
     "./child-environment": {
       "types": "./dist/child-environment.d.ts",
       "default": "./dist/child-environment.js"
@@ -68,26 +72,26 @@
     "VERSION-PIN.md"
   ],
   "dependencies": {
+    "@sequenceholdings/atlas-ui": "2.0.1",
     "@tailwindcss/postcss": "^4.1.8",
     "@tailwindcss/vite": "^4.1.8",
     "@tanstack/react-query": "^4.36.1",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.3.2",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-router-dom": "^6.30.4",
+    "react-router-dom": "^7.18.2",
     "sonner": "^2.0.7",
     "tailwindcss": "^4.1.8",
     "tw-animate-css": "^1.4.0",
     "vite": "8.0.16",
     "zod": "^4.1.13",
-    "@sequenceholdings/lattice-form-renderer": "0.1.2",
-    "@sequenceholdings/atlas-ui": "2.0.1"
+    "@sequenceholdings/lattice-form-renderer": "0.1.2"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && node scripts/copy-templates.mjs",

package/templates/react-vite/AGENTS.md

@@ -36,7 +36,7 @@ Use **pnpm** for artifacts you will deploy from git — `seq-studio artifact bui
 | `src/main.tsx` | Providers: `QueryClientProvider` → `PortalContainerProvider` → `App` |
 | `src/App.tsx` | Entrypoint UI |
 | `src/lib/api.ts` | `unwrap<T>` envelope helper + re-export of `seq` |
-| `src/styles.css` | Tailwind v4 + `@sequenceholdings/atlas-ui/tokens.css` (+ v2 sheets; build injects them when missing) |
+| `src/styles.css` | Tailwind v4 + canonical `@sequenceholdings/atlas-ui/tokens.css` |
 | `vite.config.ts` | Vite + React + Tailwind v4 plugin |
 
 ## Defaults

package/templates/react-vite/package.json

@@ -9,15 +9,15 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@sequenceholdings/artifact-studio": "^0.1.0",
-    "@sequenceholdings/atlas-ui": "^0.1.0",
+    "@sequenceholdings/artifact-studio": "^0.2.1",
+    "@sequenceholdings/atlas-ui": "^2.0.1",
     "@tailwindcss/postcss": "^4.2.2",
     "@tailwindcss/vite": "^4.2.2",
     "@tanstack/react-query": "^4.36.1",
     "@vitejs/plugin-react": "^5.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-router-dom": "^6.28.0",
+    "react-router-dom": "^7.18.2",
     "sonner": "^2.0.7",
     "tailwindcss": "^4.2.2",
     "tw-animate-css": "^1.4.0",

package/templates/react-vite/src/styles.css

@@ -1,8 +1,6 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 @import "@sequenceholdings/atlas-ui/tokens.css";
-@import "@sequenceholdings/atlas-ui/tokens.v2.css";
-@import "@sequenceholdings/atlas-ui/theme.v2.css";
 
 /* Tailwind v4 skips node_modules during automatic source detection, so the
    utility classes compiled into atlas-ui's components are never generated under