@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/rules/checkAllFiles.js

@@ -0,0 +1,749 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, dirname, extname, join, relative } from 'node:path';
+import ts from 'typescript';
+import { themeFileOf, themeTokens } from "./themeTokens.js";
+import { ascendingScales, pixelGroups, scaleGroups, textInControls, textLines } from "../theme/scales.js";
+import { IMPORT_FROM_ROOT_MESSAGE, NO_COMMENTS_MESSAGE, NO_RE_EXPORTS_MESSAGE, NO_UNUSED_EXPORTS_MESSAGE, NO_POINTER_CURSOR_MESSAGE, ACCESS_FLOWS_MESSAGE, TOASTER_ONCE_MESSAGE, SCHEMA_TABLES_MESSAGE, SCRIPTS_WIRED_MESSAGE, SRC_STRUCTURE_MESSAGE, SCROLL_VIEW_ONLY_MESSAGE, THEME_SCALES_MESSAGE } from "./messages.js";
+const ROOT = process.cwd();
+const SKIPPED_DIRECTORIES = new Set(['node_modules', 'dist', '.dev', '.git']);
+const SKIPPED_FILES = new Set(['pnpm-lock.yaml']);
+const SKIPPED_EXTENSIONS = new Set(['.md']);
+const HASH_LINE_COMMENT_FILES = new Set(['.gitignore', '.nvmrc']);
+const SHELL_SHEBANG = /^#!\s*\/(usr\/bin\/env\s+)?(bin\/)?(sh|bash|zsh)\b/;
+const SHELL_WORD_BOUNDARIES = new Set([
+    '\n',
+    ' ',
+    '\t',
+    ';',
+    '&',
+    '|',
+    '(',
+    ')'
+]);
+const MESSAGES = {
+    'import-from-root': IMPORT_FROM_ROOT_MESSAGE,
+    'no-comments': NO_COMMENTS_MESSAGE,
+    'no-re-exports': NO_RE_EXPORTS_MESSAGE,
+    'no-unused-exports': NO_UNUSED_EXPORTS_MESSAGE,
+    'no-pointer-cursor': NO_POINTER_CURSOR_MESSAGE,
+    'scroll-view-only': SCROLL_VIEW_ONLY_MESSAGE,
+    'schema-tables': SCHEMA_TABLES_MESSAGE,
+    'access-flows': ACCESS_FLOWS_MESSAGE,
+    'toaster-once': TOASTER_ONCE_MESSAGE,
+    'scripts-wired': SCRIPTS_WIRED_MESSAGE,
+    'src-structure': SRC_STRUCTURE_MESSAGE,
+    'theme-scales': THEME_SCALES_MESSAGE
+};
+const BANNED_CSS_DECLARATIONS = [
+    { pattern: /^\s*cursor\s*:[^]*\bpointer\b/i, rule: 'no-pointer-cursor' },
+    {
+        pattern: /^\s*overflow(-x|-y|-block|-inline)?\s*:[^]*\b(auto|scroll)\b/i,
+        rule: 'scroll-view-only'
+    }
+];
+function comment(offset) {
+    return { offset, rule: 'no-comments' };
+}
+const SAME_FOLDER_IMPORT = /^\.\/[^/]+$/;
+function importSpecifiers(source) {
+    const found = [];
+    const visit = (node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier !== undefined &&
+            ts.isStringLiteralLike(node.moduleSpecifier)) {
+            found.push(node.moduleSpecifier);
+        }
+        if (ts.isCallExpression(node) &&
+            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+            node.arguments[0] !== undefined &&
+            ts.isStringLiteralLike(node.arguments[0])) {
+            found.push(node.arguments[0]);
+        }
+        if (ts.isImportTypeNode(node) &&
+            ts.isLiteralTypeNode(node.argument) &&
+            ts.isStringLiteralLike(node.argument.literal)) {
+            found.push(node.argument.literal);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function relativeImports(source) {
+    return importSpecifiers(source)
+        .filter((specifier) => specifier.text.startsWith('.') &&
+        !SAME_FOLDER_IMPORT.test(specifier.text))
+        .map((specifier) => ({
+        offset: specifier.getStart(source),
+        rule: 'import-from-root'
+    }));
+}
+function scanScript(kind) {
+    return (text) => {
+        const source = ts.createSourceFile('file', text, ts.ScriptTarget.Latest, true, kind);
+        const starts = new Set();
+        const visit = (node) => {
+            if (node.kind >= ts.SyntaxKind.FirstJSDocNode &&
+                node.kind <= ts.SyntaxKind.LastJSDocNode) {
+                return;
+            }
+            if (node.kind !== ts.SyntaxKind.JsxText) {
+                for (const range of ts.getLeadingCommentRanges(text, node.getFullStart()) ?? []) {
+                    starts.add(range.pos);
+                }
+            }
+            for (const child of node.getChildren(source))
+                visit(child);
+        };
+        visit(source);
+        return [
+            ...[...starts].sort((a, b) => a - b).map(comment),
+            ...relativeImports(source)
+        ];
+    };
+}
+function skipQuoted(text, start, escapes) {
+    const quote = text[start];
+    let i = start + 1;
+    while (i < text.length && text[i] !== quote) {
+        i += escapes && text[i] === '\\' ? 2 : 1;
+    }
+    return i + 1;
+}
+function scanCss(text) {
+    const findings = [];
+    let declarationText = '';
+    let declarationStart = 0;
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === '"' || char === "'") {
+            const end = skipQuoted(text, i, true);
+            declarationText += ' '.repeat(end - i);
+            i = end;
+        }
+        else if (char === '/' && text[i + 1] === '*') {
+            findings.push(comment(i));
+            const close = text.indexOf('*/', i + 2);
+            i = close === -1 ? text.length : close + 2;
+        }
+        else if (/^url\(\s*[^"'\s]/i.test(text.slice(i, i + 6))) {
+            const close = text.indexOf(')', i);
+            i = close === -1 ? text.length : close + 1;
+        }
+        else if (char === ';' || char === '{' || char === '}') {
+            for (const banned of BANNED_CSS_DECLARATIONS) {
+                if (banned.pattern.test(declarationText)) {
+                    findings.push({ offset: declarationStart, rule: banned.rule });
+                }
+            }
+            declarationText = '';
+            declarationStart = i + 1;
+            i += 1;
+        }
+        else {
+            if (declarationText.trim() === '' && !/\s/.test(char ?? '')) {
+                declarationStart = i;
+            }
+            declarationText += char;
+            i += 1;
+        }
+    }
+    return findings;
+}
+function scanJson(text) {
+    const findings = [];
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === '"') {
+            i = skipQuoted(text, i, true);
+        }
+        else if (char === '/' && (text[i + 1] === '/' || text[i + 1] === '*')) {
+            findings.push(comment(i));
+            const close = text[i + 1] === '/' ? text.indexOf('\n', i) : text.indexOf('*/', i + 2);
+            i = close === -1 ? text.length : close + 2;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return findings;
+}
+function scanEmbedded(scanner, text, offset) {
+    return scanner(text).map((finding) => ({
+        ...finding,
+        offset: finding.offset + offset
+    }));
+}
+function scanMarkup(text) {
+    const findings = [];
+    let i = 0;
+    while (i < text.length) {
+        if (text.startsWith('<!--', i)) {
+            findings.push(comment(i));
+            const close = text.indexOf('-->', i + 4);
+            i = close === -1 ? text.length : close + 3;
+            continue;
+        }
+        if (text[i] !== '<') {
+            i += 1;
+            continue;
+        }
+        const tagName = /^<([a-zA-Z][\w-]*)/.exec(text.slice(i))?.[1]?.toLowerCase();
+        let j = i + 1;
+        while (j < text.length && text[j] !== '>') {
+            j =
+                text[j] === '"' || text[j] === "'" ? skipQuoted(text, j, false) : j + 1;
+        }
+        i = j + 1;
+        if (tagName === 'script' || tagName === 'style') {
+            const closeTag = text.toLowerCase().indexOf(`</${tagName}`, i);
+            const end = closeTag === -1 ? text.length : closeTag;
+            const scanner = tagName === 'style' ? scanCss : scanScript(ts.ScriptKind.JS);
+            findings.push(...scanEmbedded(scanner, text.slice(i, end), i));
+            i = end;
+        }
+    }
+    return findings;
+}
+function scanShell(text) {
+    const findings = [];
+    let i = text.startsWith('#!') ? text.indexOf('\n') + 1 || text.length : 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === "'") {
+            i = skipQuoted(text, i, false);
+        }
+        else if (char === '"') {
+            i = skipQuoted(text, i, true);
+        }
+        else if (char === '\\') {
+            i += 2;
+        }
+        else if (char === '#' &&
+            (i === 0 || SHELL_WORD_BOUNDARIES.has(text[i - 1] ?? ''))) {
+            findings.push(comment(i));
+            const close = text.indexOf('\n', i);
+            i = close === -1 ? text.length : close;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return findings;
+}
+function scanYaml(text) {
+    const findings = [];
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === "'" || char === '"') {
+            i = skipQuoted(text, i, char === '"');
+        }
+        else if (char === '#' &&
+            (i === 0 || [' ', '\t', '\n'].includes(text[i - 1] ?? ''))) {
+            findings.push(comment(i));
+            const close = text.indexOf('\n', i);
+            i = close === -1 ? text.length : close;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return findings;
+}
+function scanHashLines(text) {
+    const findings = [];
+    let lineStart = 0;
+    for (const line of text.split('\n')) {
+        if (line.trimStart().startsWith('#')) {
+            findings.push(comment(lineStart + line.indexOf('#')));
+        }
+        lineStart += line.length + 1;
+    }
+    return findings;
+}
+const SCANNERS_BY_EXTENSION = {
+    '.ts': scanScript(ts.ScriptKind.TS),
+    '.mts': scanScript(ts.ScriptKind.TS),
+    '.cts': scanScript(ts.ScriptKind.TS),
+    '.tsx': scanScript(ts.ScriptKind.TSX),
+    '.js': scanScript(ts.ScriptKind.JS),
+    '.mjs': scanScript(ts.ScriptKind.JS),
+    '.cjs': scanScript(ts.ScriptKind.JS),
+    '.jsx': scanScript(ts.ScriptKind.JSX),
+    '.css': scanCss,
+    '.json': scanJson,
+    '.html': scanMarkup,
+    '.svg': scanMarkup,
+    '.yaml': scanYaml,
+    '.yml': scanYaml
+};
+function scannerFor(path, text) {
+    const name = basename(path);
+    if (HASH_LINE_COMMENT_FILES.has(name))
+        return scanHashLines;
+    const extension = extname(name);
+    if (extension !== '')
+        return SCANNERS_BY_EXTENSION[extension];
+    return SHELL_SHEBANG.test(text) ? scanShell : undefined;
+}
+function ownedFiles(directory) {
+    return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return SKIPPED_DIRECTORIES.has(entry.name) ? [] : ownedFiles(path);
+        }
+        if (SKIPPED_FILES.has(entry.name) ||
+            SKIPPED_EXTENSIONS.has(extname(entry.name))) {
+            return [];
+        }
+        return [path];
+    });
+}
+function lineAndColumn(text, offset) {
+    const before = text.slice(0, offset).split('\n');
+    return `${before.length}:${(before.at(-1)?.length ?? 0) + 1}`;
+}
+const SCRIPTS_DIRECTORY = join(ROOT, 'scripts');
+const FLOWS_DIRECTORY = join(ROOT, 'flows');
+const SCRIPT_WIRING_FILES = ['package.json', 'app', 'vite.config.ts'];
+function unwiredScripts() {
+    if (!existsSync(SCRIPTS_DIRECTORY))
+        return [];
+    const scripts = ownedFiles(SCRIPTS_DIRECTORY).filter((path) => extname(path) === '.ts');
+    const wiring = SCRIPT_WIRING_FILES.map((file) => readFileSync(join(ROOT, file), 'utf8')).join('\n');
+    const sources = [...scripts, ...ownedFiles(FLOWS_DIRECTORY)].map((path) => ({
+        path,
+        text: readFileSync(path, 'utf8')
+    }));
+    return scripts.filter((path) => {
+        const isInLabelledFolder = relative(SCRIPTS_DIRECTORY, path).includes('/');
+        const name = basename(path);
+        const isUsed = wiring.includes(relative(ROOT, path)) ||
+            sources.some((other) => other.path !== path &&
+                (other.text.includes(`/${name}'`) || other.text.includes(`'${name}'`)));
+        return !isInLabelledFolder || !isUsed;
+    });
+}
+const SRC_DIRECTORY = join(ROOT, 'src');
+const SRC_ENTRY_FILES = new Set([
+    'App.ts',
+    'models/index.ts',
+    'stores/index.ts',
+    'services/index.ts',
+    'actions/index.ts',
+    'main.tsx',
+    'routes.tsx',
+    'index.css'
+]);
+const SRC_FOLDER_PATTERNS = [
+    /^theme\/(theme|icons)\.ts$/,
+    /^lib\/[a-z][A-Za-z]*\.ts$/,
+    /^hooks\/use[A-Z][A-Za-z]*\.ts$/,
+    /^screens\/[A-Z][A-Za-z]*Screen\.tsx$/,
+    /^layouts\/[A-Z][A-Za-z]*Layout\.tsx$/,
+    /^models\/[A-Z][A-Za-z]*\.ts$/,
+    /^stores\/[A-Z][A-Za-z]*\.ts$/,
+    /^services\/[a-z][A-Za-z]*\.ts$/,
+    /^actions\/[a-z][A-Za-z]*\.ts$/
+];
+const PREFIXED_FOLDER_FILE = /^(components)\/([A-Z][A-Za-z]*)\/([A-Z][A-Za-z]*)\.tsx?$/;
+function isWhereItBelongs(path) {
+    if (SRC_ENTRY_FILES.has(path))
+        return true;
+    if (SRC_FOLDER_PATTERNS.some((pattern) => pattern.test(path)))
+        return true;
+    const grouped = PREFIXED_FOLDER_FILE.exec(path);
+    const folder = grouped?.[2];
+    const file = grouped?.[3];
+    return folder !== undefined && file !== undefined && file.startsWith(folder);
+}
+const MODULE_FILE = /\.(ts|tsx|mts|cts)$/;
+const CLASS_HOMES = [
+    { pattern: /\bextends\s+Model\s*\(/, folder: 'models/' },
+    { pattern: /\bextends\s+Store\s*\(/, folder: 'stores/' },
+    { pattern: /\bdefineServices\s*\(/, folder: 'services/' },
+    { pattern: /\bdefineActions\s*\(/, folder: 'actions/' }
+];
+function isInItsFolder(path) {
+    const inSrc = relative(SRC_DIRECTORY, path);
+    if (!MODULE_FILE.test(path))
+        return true;
+    const text = readFileSync(path, 'utf8');
+    return CLASS_HOMES.every(({ pattern, folder }) => !pattern.test(text) || inSrc.startsWith(folder));
+}
+function misplacedSourceFiles() {
+    return ownedFiles(SRC_DIRECTORY).filter((path) => !isWhereItBelongs(relative(SRC_DIRECTORY, path)) || !isInItsFolder(path));
+}
+const SCHEMA_FILE = join(ROOT, 'schema.ts');
+function rowTypeName(table) {
+    const one = table.endsWith('ies')
+        ? `${table.slice(0, -3)}y`
+        : table.endsWith('s')
+            ? table.slice(0, -1)
+            : table;
+    return `${one.charAt(0).toUpperCase()}${one.slice(1)}`;
+}
+function isExported(node) {
+    return (ts.canHaveModifiers(node) &&
+        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+function schemaFindings() {
+    if (!existsSync(SCHEMA_FILE))
+        return [];
+    const text = readFileSync(SCHEMA_FILE, 'utf8');
+    const source = ts.createSourceFile(SCHEMA_FILE, text, ts.ScriptTarget.Latest, true);
+    const tables = [];
+    const rowTypes = new Set();
+    let exportsTables = false;
+    let exportsAdmins = false;
+    const visit = (node) => {
+        if (ts.isVariableStatement(node) &&
+            isExported(node) &&
+            node.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) &&
+                declaration.name.text === 'admins')) {
+            exportsAdmins = true;
+        }
+        if (ts.isVariableStatement(node) &&
+            isExported(node) &&
+            node.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) &&
+                declaration.name.text === 'tables' &&
+                declaration.initializer !== undefined &&
+                ts.isCallExpression(declaration.initializer) &&
+                declaration.initializer.expression.getText(source) === 'defineTables')) {
+            exportsTables = true;
+        }
+        if (ts.isCallExpression(node) &&
+            node.expression.getText(source) === 'defineTables') {
+            const [definitions] = node.arguments;
+            if (definitions !== undefined &&
+                ts.isObjectLiteralExpression(definitions)) {
+                for (const property of definitions.properties) {
+                    const name = property.name;
+                    if (name !== undefined &&
+                        (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
+                        tables.push({ key: name.text, offset: property.getStart(source) });
+                    }
+                }
+            }
+        }
+        if (ts.isTypeAliasDeclaration(node) &&
+            isExported(node) &&
+            ts.isTypeReferenceNode(node.type) &&
+            node.type.typeName.getText(source) === 'Row') {
+            const [argument] = node.type.typeArguments ?? [];
+            if (argument !== undefined && ts.isTypeQueryNode(argument)) {
+                rowTypes.add(argument.exprName.getText(source));
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    if (!exportsTables) {
+        return [
+            {
+                offset: 0,
+                fix: 'export const tables = defineTables({ ... })'
+            }
+        ];
+    }
+    const missingAdmins = exportsAdmins
+        ? []
+        : [{ offset: 0, fix: 'export const admins: string[] = []' }];
+    return [
+        ...missingAdmins,
+        ...tables
+            .filter(({ key }) => !rowTypes.has(`tables.${key}`))
+            .map(({ key, offset }) => ({
+            offset,
+            fix: `export type ${rowTypeName(key)} = Row<typeof tables.${key}>`
+        }))
+    ];
+}
+const ACCESS_FLOWS_FILE = join(ROOT, 'flows', 'Access.flow.ts');
+function toasterPlacements() {
+    return ownedFiles(SRC_DIRECTORY)
+        .filter((path) => path.endsWith('.tsx'))
+        .reduce((count, path) => count + (readFileSync(path, 'utf8').match(/<Toaster\b/g)?.length ?? 0), 0);
+}
+function runsAccessFlows() {
+    if (!existsSync(SCHEMA_FILE))
+        return true;
+    if (!existsSync(ACCESS_FLOWS_FILE))
+        return false;
+    const text = readFileSync(ACCESS_FLOWS_FILE, 'utf8');
+    return (/from '@trypattern\/sdk\/flows'/.test(text) &&
+        /accessFlows\(\s*\{\s*App\s*\}\s*\)/.test(text));
+}
+const WORKER_ENTRY = 'server/worker.ts';
+const CONVENTION_EXPORTS = {
+    'schema.ts': ['tables', 'admins'],
+    'seed.ts': ['seed'],
+    'vite.config.ts': ['default'],
+    'server/worker.ts': ['default']
+};
+const EVERYTHING = '*';
+function bindingNames(name) {
+    if (ts.isIdentifier(name))
+        return [name];
+    return name.elements.flatMap((element) => ts.isOmittedExpression(element) ? [] : bindingNames(element.name));
+}
+function resolveSpecifier(from, specifier) {
+    if (specifier.startsWith('@/'))
+        return join(ROOT, specifier.slice(2));
+    if (specifier.startsWith('.'))
+        return join(dirname(from), specifier);
+    return undefined;
+}
+function moduleFacts(path, text) {
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, path.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const imported = new Set();
+    const exported = [];
+    const passedThrough = [];
+    const uses = [];
+    const use = (specifier, names) => {
+        if (!ts.isStringLiteralLike(specifier))
+            return;
+        const target = resolveSpecifier(path, specifier.text);
+        if (target !== undefined)
+            uses.push({ target, names });
+    };
+    const exportedAt = (name) => ({
+        name: name.text,
+        offset: name.getStart(source)
+    });
+    for (const statement of source.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            const clause = statement.importClause;
+            const names = [];
+            if (clause?.name !== undefined) {
+                names.push('default');
+                imported.add(clause.name.text);
+            }
+            const bindings = clause?.namedBindings;
+            if (bindings !== undefined && ts.isNamespaceImport(bindings)) {
+                names.push(EVERYTHING);
+                imported.add(bindings.name.text);
+            }
+            if (bindings !== undefined && ts.isNamedImports(bindings)) {
+                for (const element of bindings.elements) {
+                    names.push((element.propertyName ?? element.name).text);
+                    imported.add(element.name.text);
+                }
+            }
+            use(statement.moduleSpecifier, names);
+        }
+        else if (ts.isExportDeclaration(statement)) {
+            const clause = statement.exportClause;
+            if (statement.moduleSpecifier !== undefined) {
+                use(statement.moduleSpecifier, clause !== undefined && ts.isNamedExports(clause)
+                    ? clause.elements.map((element) => (element.propertyName ?? element.name).text)
+                    : [EVERYTHING]);
+                if (clause !== undefined && ts.isNamedExports(clause)) {
+                    passedThrough.push(...clause.elements.map((element) => exportedAt(element.name)));
+                }
+                else {
+                    passedThrough.push({
+                        name: EVERYTHING,
+                        offset: statement.getStart(source)
+                    });
+                }
+            }
+            else if (clause !== undefined && ts.isNamedExports(clause)) {
+                for (const element of clause.elements) {
+                    const local = (element.propertyName ?? element.name).text;
+                    const target = imported.has(local) ? passedThrough : exported;
+                    target.push(exportedAt(element.name));
+                }
+            }
+        }
+        else if (ts.isExportAssignment(statement)) {
+            exported.push({ name: 'default', offset: statement.getStart(source) });
+        }
+        else if (isExported(statement)) {
+            const isDefault = ((ts.canHaveModifiers(statement) && ts.getModifiers(statement)) ||
+                []).some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+            if (ts.isVariableStatement(statement)) {
+                for (const declaration of statement.declarationList.declarations) {
+                    exported.push(...bindingNames(declaration.name).map(exportedAt));
+                }
+            }
+            else if (isDefault) {
+                exported.push({ name: 'default', offset: statement.getStart(source) });
+            }
+            else if ((ts.isFunctionDeclaration(statement) ||
+                ts.isClassDeclaration(statement) ||
+                ts.isTypeAliasDeclaration(statement) ||
+                ts.isInterfaceDeclaration(statement) ||
+                ts.isEnumDeclaration(statement)) &&
+                statement.name !== undefined) {
+                exported.push(exportedAt(statement.name));
+            }
+        }
+    }
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+            node.arguments[0] !== undefined) {
+            use(node.arguments[0], [EVERYTHING]);
+        }
+        if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+            use(node.argument.literal, [
+                node.qualifier?.getText(source).split('.')[0] ?? EVERYTHING
+            ]);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return { exported, passedThrough, uses };
+}
+function exportFindings() {
+    const modules = new Map(ownedFiles(ROOT)
+        .filter((path) => MODULE_FILE.test(path))
+        .map((path) => [path, moduleFacts(path, readFileSync(path, 'utf8'))]));
+    const used = new Map();
+    for (const facts of modules.values()) {
+        for (const { target, names } of facts.uses) {
+            const set = used.get(target) ?? new Set();
+            for (const name of names)
+                set.add(name);
+            used.set(target, set);
+        }
+    }
+    return [...modules].flatMap(([path, facts]) => {
+        const kept = CONVENTION_EXPORTS[relative(ROOT, path)] ?? [];
+        const names = used.get(path) ?? new Set();
+        const isWorkerEntry = relative(ROOT, path) === WORKER_ENTRY;
+        return [
+            ...(isWorkerEntry ? [] : facts.passedThrough).map(({ offset }) => ({
+                path,
+                offset,
+                rule: 'no-re-exports'
+            })),
+            ...facts.exported
+                .filter(({ name }) => !isWorkerEntry &&
+                !kept.includes(name) &&
+                !names.has(name) &&
+                !names.has(EVERYTHING))
+                .map(({ offset }) => ({ path, offset, rule: 'no-unused-exports' }))
+        ];
+    });
+}
+const THEME_FILE = themeFileOf(ROOT);
+const PIXELS = /^(\d+(\.\d+)?)px$/;
+function themeScaleFindings() {
+    if (!existsSync(THEME_FILE))
+        return [];
+    const tokens = themeTokens(ROOT);
+    const findings = [];
+    const pixels = (name) => {
+        const match = PIXELS.exec(tokens.get(name)?.value ?? '');
+        return match === null ? undefined : Number(match[1]);
+    };
+    const report = (names, detail) => {
+        const offset = names
+            .map((name) => tokens.get(name)?.offset)
+            .find((found) => found !== undefined);
+        if (offset !== undefined) {
+            findings.push({ offset, rule: `theme-scales ${detail}` });
+        }
+    };
+    for (const [name, { value, offset }] of tokens) {
+        const [group] = name.split('.');
+        if (offset === undefined)
+            continue;
+        if (!pixelGroups.some((pixelGroup) => pixelGroup === group))
+            continue;
+        if (PIXELS.test(value) &&
+            (Number.isInteger(pixels(name)) || group === 'borders')) {
+            continue;
+        }
+        findings.push({
+            offset,
+            rule: `theme-scales ${name} is ${value}; write whole pixels like '28px', never em, % or calc(), so the scales can be checked against each other.`
+        });
+    }
+    for (const [scale, keys] of Object.entries(ascendingScales)) {
+        const group = scaleGroups[scale];
+        keys.slice(1).forEach((key, index) => {
+            const smaller = `${group}.${keys[index]}`;
+            const larger = `${group}.${key}`;
+            const below = pixels(smaller);
+            const above = pixels(larger);
+            if (below !== undefined && above !== undefined && above < below) {
+                report([larger, smaller], `${larger} (${above}px) is smaller than ${smaller} (${below}px); each step of a scale is at least as large as the one before it.`);
+            }
+        });
+    }
+    for (const { size, height, lineHeight } of textInControls) {
+        const control = pixels(`controls.${height}`);
+        const line = pixels(`lineHeights.${lineHeight}`);
+        const icon = pixels(`iconSizes.${size}`);
+        if (control !== undefined && line !== undefined && control < line) {
+            report([`controls.${height}`, `lineHeights.${lineHeight}`], `controls.${height} (${control}px) is smaller than lineHeights.${lineHeight} (${line}px), so text in a size ${size} button, field or menu item would clip. Raise the height or lower the line height; the two scales move together.`);
+        }
+        if (control !== undefined && icon !== undefined && icon > control) {
+            report([`iconSizes.${size}`, `controls.${height}`], `iconSizes.${size} (${icon}px) is larger than controls.${height} (${control}px), so the icon would overflow a size ${size} control.`);
+        }
+    }
+    for (const { lineHeight, fontSize } of textLines) {
+        const line = pixels(`lineHeights.${lineHeight}`);
+        const font = pixels(`fontSizes.${fontSize}`);
+        if (line !== undefined && font !== undefined && line < font) {
+            report([`lineHeights.${lineHeight}`, `fontSizes.${fontSize}`], `lineHeights.${lineHeight} (${line}px) is smaller than fontSizes.${fontSize} (${font}px), so lines of that text would overlap. Re-value them as a pair.`);
+        }
+    }
+    return findings;
+}
+const findingLines = [];
+const violatedRules = new Set();
+let scannedCount = 0;
+for (const path of ownedFiles(ROOT)) {
+    const text = readFileSync(path, 'utf8');
+    const scanner = scannerFor(path, text);
+    if (scanner === undefined)
+        continue;
+    scannedCount += 1;
+    for (const finding of scanner(text)) {
+        violatedRules.add(finding.rule);
+        findingLines.push(`${relative(ROOT, path)}:${lineAndColumn(text, finding.offset)}: pattern(${finding.rule})`);
+    }
+}
+for (const { path, offset, rule } of exportFindings()) {
+    violatedRules.add(rule);
+    findingLines.push(`${relative(ROOT, path)}:${lineAndColumn(readFileSync(path, 'utf8'), offset)}: pattern(${rule})`);
+}
+for (const finding of themeScaleFindings()) {
+    violatedRules.add('theme-scales');
+    findingLines.push(`${relative(ROOT, THEME_FILE)}:${lineAndColumn(readFileSync(THEME_FILE, 'utf8'), finding.offset)}: pattern(${finding.rule})`);
+}
+for (const path of misplacedSourceFiles()) {
+    violatedRules.add('src-structure');
+    findingLines.push(`${relative(ROOT, path)}:1:1: pattern(src-structure)`);
+}
+for (const { offset, fix } of schemaFindings()) {
+    violatedRules.add('schema-tables');
+    findingLines.push(`schema.ts:${lineAndColumn(readFileSync(SCHEMA_FILE, 'utf8'), offset)}: pattern(schema-tables) add: ${fix}`);
+}
+if (!runsAccessFlows()) {
+    violatedRules.add('access-flows');
+    findingLines.push(`${relative(ROOT, ACCESS_FLOWS_FILE)}:1:1: pattern(access-flows)`);
+}
+if (existsSync(SRC_DIRECTORY) && toasterPlacements() !== 1) {
+    violatedRules.add('toaster-once');
+    findingLines.push('src/layouts/AppLayout.tsx:1:1: pattern(toaster-once)');
+}
+for (const path of unwiredScripts()) {
+    violatedRules.add('scripts-wired');
+    findingLines.push(`${relative(ROOT, path)}:1:1: pattern(scripts-wired)`);
+}
+if (findingLines.length > 0) {
+    const guidance = [...violatedRules].map((rule) => `pattern(${rule}): ${MESSAGES[rule] ?? rule}`);
+    process.stdout.write(`${[...findingLines, '', ...guidance].join('\n')}\n`);
+    process.exitCode = 1;
+}
+else {
+    process.stdout.write(`No Pattern source rule violations in ${scannedCount} files\n`);
+}