@dxos/eslint-plugin-rules 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/docs/2025-04-03-translation-key-normalization-design.md

@@ -0,0 +1,94 @@
+# Translation Key Normalization
+
+## Status
+
+ESLint rule and migration script ready. Tested on `plugin-chess`.
+
+## Problem
+
+1,326 translation keys across 56 plugins use inconsistent space-separated naming with no enforced suffix convention. 135 keys lack a type suffix entirely. This makes it hard to grep, autocomplete, or validate keys.
+
+## Convention
+
+**Format:** `segment.kebab-case.suffix`
+
+```
+settings.debug.label
+add-comment.label
+object-name.placeholder
+add-section.before-dialog.title
+typename.label_other
+```
+
+### Rules
+
+- Every key ends with a **type suffix**: `label | message | placeholder | title | description | heading | alt | button`.
+- Plural suffixes append after the type suffix: `typename.label_zero`, `lobby.participants_other`.
+- Dots separate hierarchical segments; segments use kebab-case.
+- `plugin name` keys become `plugin.label`.
+
+## Tools
+
+### 1. ESLint Rule (ongoing enforcement)
+
+`packages/common/eslint-plugin-rules/rules/translation-key-format.js`
+
+Registered in `.oxlintrc.json` as `@dxos/eslint-plugin-rules/translation-key-format` (currently `warn`).
+
+**Checks:**
+
+- `useDotsNotSpaces` — flags space-separated keys, suggests dot.kebab-case, auto-fixable.
+- `missingSuffix` — flags keys missing a valid type suffix (not auto-fixable, needs human decision).
+
+**Catches violations in:**
+
+- `t('key')` calls in source files.
+- Property keys in `translations.ts` files (string literal keys with string literal values).
+
+**Auto-fix:** `moon run plugin-name:lint -- --fix` rewrites both definitions and usages.
+
+**Promote to error** once migration is complete to prevent regressions.
+
+### 2. Checker Script (bulk analysis)
+
+`scripts/check-translations.mts` — run via `npx tsx scripts/check-translations.mts`.
+
+Reports:
+
+| Check                                  | Current Count |
+| -------------------------------------- | ------------- |
+| Missing keys (used but undefined)      | 68            |
+| Unused keys (defined but unreferenced) | 444           |
+| Incomplete plurals                     | 8             |
+| Missing suffix                         | 135           |
+| Non-hierarchical (space-separated)     | 1,326         |
+
+Use this for bulk analysis, migration planning, and tracking progress.
+
+## Migration Plan
+
+### Step 1: Fix known edge cases in normalizer
+
+- `plugin name` → `plugin.label` (special case).
+- Keys ending in nouns (`key`, `name`, `count`, `period`) that aren't valid suffixes need a suffix appended.
+
+### Step 2: Migrate incrementally with `--fix`
+
+Per plugin: `moon run plugin-name:lint -- --fix`, then verify with `moon run plugin-name:lint`.
+
+Start with small plugins (`plugin-chess`, `plugin-template`), then batch the rest.
+
+### Step 3: Validate
+
+- Re-run checker script to confirm counts decrease.
+- Build + test the migrated plugins.
+
+### Step 4: Promote to error
+
+Change `.oxlintrc.json` from `"warn"` to `"error"` once all plugins are clean.
+
+## Out of Scope
+
+- Moving to JSON files.
+- Cleaning up unused keys (separate effort using checker output).
+- UI packages / `osTranslations` namespace (phase 2).

package/docs/README.md

@@ -1,7 +1,5 @@
 # @dxos/eslint-plugin-rules
 
-
-
 ## Dependency Graph
 
 ```mermaid
@@ -28,4 +26,4 @@ linkStyle default stroke:#333,stroke-width:1px
 ## Dependencies
 
 | Module | Direct |
-|---|---|
+| ------ | ------ |

package/index.js

@@ -2,11 +2,16 @@
 // Copyright 2022 DXOS.org
 //
 
+import fs from 'node:fs';
+
 import comment from './rules/comment.js';
 import effectSubpathImports from './rules/effect-subpath-imports.js';
 import header from './rules/header.js';
+import importAsNamespace from './rules/import-as-namespace.js';
+import noBareDotImports from './rules/no-bare-dot-imports.js';
+import noEffectRunPromise from './rules/no-effect-run-promise.js';
 import noEmptyPromiseCatch from './rules/no-empty-promise-catch.js';
-import fs from 'node:fs';
+import translationKeyFormat from './rules/translation-key-format.js';
 
 const pkg = JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
 
@@ -20,7 +25,11 @@ const plugin = {
     comment,
     'effect-subpath-imports': effectSubpathImports,
     header,
+    'import-as-namespace': importAsNamespace,
+    'no-bare-dot-imports': noBareDotImports,
+    'no-effect-run-promise': noEffectRunPromise,
     'no-empty-promise-catch': noEmptyPromiseCatch,
+    'translation-key-format': translationKeyFormat,
   },
   configs: {
     recommended: {
@@ -30,6 +39,9 @@ const plugin = {
       rules: {
         'dxos-plugin/effect-subpath-imports': 'error',
         'dxos-plugin/header': 'error',
+        'dxos-plugin/import-as-namespace': 'error',
+        'dxos-plugin/no-bare-dot-imports': 'error',
+        'dxos-plugin/no-effect-run-promise': 'error',
         'dxos-plugin/no-empty-promise-catch': 'error',
         // TODO(dmaretskyi): Turned off due to large number of errors and no auto-fix.
         // 'dxos-plugin/comment': 'error',

package/moon.yml

@@ -1,2 +1,2 @@
-type: library
+layer: library
 language: typescript

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@dxos/eslint-plugin-rules",
-  "version": "0.8.4-main.ae835ea",
+  "version": "0.8.4-main.bcb3aa67d6",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": true,

package/rules/effect-subpath-imports.js

@@ -4,9 +4,23 @@
 
 import { createRequire } from 'node:module';
 
-
 const EXCLUDED_EFFECT_PACKAGES = ['@effect/vitest'];
 
+/**
+ * Map of Effect base-package exports that come from a subpath (not a direct segment).
+ * Used when resolving imports like `import { pipe } from 'effect'` → effect/Function.
+ */
+const EFFECT_EXPORT_TO_SUBPATH = {
+  pipe: 'Function',
+  flow: 'Function',
+};
+
+/**
+ * Subpaths that allow named imports (e.g. `import { pipe, flow } from 'effect/Function'`).
+ * Other subpaths still require namespace imports.
+ */
+const NAMED_IMPORT_ALLOWED_SUBPATHS = new Set(['Function']);
+
 /**
  * ESLint rule to transform combined imports from 'effect' and '@effect/*'
  * into subpath imports except for the EXCLUDED_EFFECT_PACKAGES.
@@ -59,6 +73,15 @@ export default {
       return exported.has(segment);
     };
 
+    const resolveExportToSegment = (pkgName, exportName) => {
+      if (isValidSubpath(pkgName, exportName)) return exportName;
+      if (pkgName === 'effect' && EFFECT_EXPORT_TO_SUBPATH[exportName]) {
+        const segment = EFFECT_EXPORT_TO_SUBPATH[exportName];
+        return isValidSubpath(pkgName, segment) ? segment : null;
+      }
+      return null;
+    };
+
     const isEffectPackage = (source) => {
       return source === 'effect' || source.startsWith('effect/') || source.startsWith('@effect/');
     };
@@ -66,7 +89,7 @@ export default {
     const shouldSkipEffectPackage = (basePackage) => {
       return EXCLUDED_EFFECT_PACKAGES.includes(basePackage);
     };
-    
+
     /**
      * Get the base package name from a source string.
      * @param {string} source - The source string to get the base package name from.
@@ -91,11 +114,13 @@ export default {
         const basePackage = getBasePackage(source);
         if (shouldSkipEffectPackage(basePackage)) return;
 
-        // If it's a subpath import (e.g., 'effect/Schema'), enforce namespace import only.
+        // If it's a subpath import (e.g., 'effect/Schema'), enforce namespace import except for allowed subpaths.
         if (source.startsWith(basePackage + '/')) {
+          const segment = source.slice(basePackage.length + 1);
+          const allowsNamed = NAMED_IMPORT_ALLOWED_SUBPATHS.has(segment);
           const isNamespaceOnly =
             node.specifiers.length === 1 && node.specifiers[0].type === 'ImportNamespaceSpecifier';
-          if (!isNamespaceOnly) {
+          if (!allowsNamed && !isNamespaceOnly) {
             context.report({
               node,
               message: 'Use namespace import for Effect subpaths',
@@ -129,18 +154,22 @@ export default {
           else regularImports.push(entry);
         }
 
-        // Partition into resolvable vs unresolved specifiers.
+        // Partition into resolvable vs unresolved specifiers (resolved entries include segment for fix).
         const resolvedType = [];
         const unresolvedType = [];
         const resolvedRegular = [];
         const unresolvedRegular = [];
 
-        typeImports.forEach((s) =>
-          isValidSubpath(packageName, s.imported) ? resolvedType.push(s) : unresolvedType.push(s),
-        );
-        regularImports.forEach((s) =>
-          isValidSubpath(packageName, s.imported) ? resolvedRegular.push(s) : unresolvedRegular.push(s),
-        );
+        typeImports.forEach((spec) => {
+          const segment = resolveExportToSegment(packageName, spec.imported);
+          if (segment) resolvedType.push({ ...spec, segment });
+          else unresolvedType.push(spec);
+        });
+        regularImports.forEach((spec) => {
+          const segment = resolveExportToSegment(packageName, spec.imported);
+          if (segment) resolvedRegular.push({ ...spec, segment });
+          else unresolvedRegular.push(spec);
+        });
 
         const unresolved = [...unresolvedType, ...unresolvedRegular].map(({ imported }) => imported);
 
@@ -160,27 +189,55 @@ export default {
               return null;
             }
 
-            // Prefer regular (value) imports over type imports on duplicates.
-            const seenResolved = new Set(); // key: `${alias}|${segment}`
-
-            // First, emit value imports and record keys.
-            resolvedRegular.forEach(({ imported, local }) => {
-              const alias = imported !== local ? local : imported;
-              const key = `${alias}|${imported}`;
-              if (seenResolved.has(key)) return;
-              seenResolved.add(key);
-              imports.push(`import * as ${alias} from '${packageName}/${imported}';`);
+            // Group resolved imports by segment.
+            const bySegment = new Map(); // segment -> { regular: [...], type: [...] }
+            resolvedRegular.forEach((entry) => {
+              const seg = entry.segment;
+              let group = bySegment.get(seg);
+              if (!group) {
+                group = { regular: [], type: [] };
+                bySegment.set(seg, group);
+              }
+              group.regular.push(entry);
             });
-
-            // Then, emit type imports only if a value import for the same alias/segment was not emitted.
-            resolvedType.forEach(({ imported, local }) => {
-              const alias = imported !== local ? local : imported;
-              const key = `${alias}|${imported}`;
-              if (seenResolved.has(key)) return; // skip type if value exists
-              seenResolved.add(key);
-              imports.push(`import type * as ${alias} from '${packageName}/${imported}';`);
+            resolvedType.forEach((entry) => {
+              const seg = entry.segment;
+              let group = bySegment.get(seg);
+              if (!group) {
+                group = { regular: [], type: [] };
+                bySegment.set(seg, group);
+              }
+              group.type.push(entry);
             });
 
+            for (const [segment, group] of bySegment) {
+              const useNamed = NAMED_IMPORT_ALLOWED_SUBPATHS.has(segment);
+              const merged = [...group.regular];
+              for (const t of group.type) {
+                if (!group.regular.some((r) => r.local === t.local)) merged.push(t);
+              }
+              if (useNamed && merged.length > 0) {
+                const specParts = merged.map(({ imported, local }) =>
+                  imported !== local ? `${imported} as ${local}` : imported,
+                );
+                imports.push(`import { ${specParts.join(', ')} } from '${packageName}/${segment}';`);
+              } else {
+                const seen = new Set();
+                for (const { imported, local } of merged) {
+                  const alias = imported !== local ? local : imported;
+                  if (seen.has(alias)) continue;
+                  seen.add(alias);
+                  const isTypeOnly =
+                    group.type.some((t) => t.imported === imported) &&
+                    !group.regular.some((r) => r.imported === imported);
+                  const importStr = isTypeOnly
+                    ? `import type * as ${alias} from '${packageName}/${segment}';`
+                    : `import * as ${alias} from '${packageName}/${segment}';`;
+                  imports.push(importStr);
+                }
+              }
+            }
+
             // If there are unresolved, keep them in a single base import.
             if (unresolvedType.length || unresolvedRegular.length) {
               // Prefer value over type for the same local alias when both are present.

package/rules/import-as-namespace.js

@@ -0,0 +1,271 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DIRECTIVE_TEXT = '@import-as-namespace';
+const DIRECTIVE_LINE_REGEX = /^\s*\/\/\s*@import-as-namespace\s*$/m;
+const PASCAL_CASE_REGEX = /^[A-Z][a-zA-Z0-9]*$/;
+const TS_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+
+/**
+ * ESLint rule to enforce namespace imports for modules annotated with `// @import-as-namespace`.
+ *
+ * When a module contains the `// @import-as-namespace` directive comment, this rule enforces:
+ * - The module filename is PascalCase (e.g. `LanguageModel.ts`).
+ * - All imports of the module use namespace form: `import * as LanguageModel from './LanguageModel'`.
+ * - The namespace name matches the filename (without extension), or has a `Module` suffix.
+ * - Re-exports use namespace form: `export * as LanguageModel from './LanguageModel'`.
+ *
+ * The `Module` suffix is allowed as an escape hatch when the expected namespace name conflicts
+ * with a local declaration in the importing file (e.g., `import * as ObjModule from './Obj'`
+ * when the file also exports its own `Obj` interface).
+ *
+ * @example
+ * // In LanguageModel.ts:
+ * // @import-as-namespace
+ * export const foo = 1;
+ *
+ * // ❌ Bad (in another file):
+ * import { foo } from './LanguageModel';
+ * export { foo } from './LanguageModel';
+ * export * from './LanguageModel';
+ *
+ * // ✅ Good:
+ * import * as LanguageModel from './LanguageModel';
+ * import * as LanguageModelModule from './LanguageModel';  // Also allowed when needed
+ * export * as LanguageModel from './LanguageModel';
+ */
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'enforce namespace imports for modules marked with @import-as-namespace',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      filenameMustBePascalCase:
+        'Module marked with @import-as-namespace must have a PascalCase filename. Got: "{{filename}}".',
+      mustUseNamespaceImport:
+        'Module "{{source}}" is marked @import-as-namespace. Use: `import * as {{namespace}} from \'{{source}}\'`.',
+      namespaceMustMatchFilename: 'Namespace import name "{{actual}}" must match filename "{{expected}}".',
+      mustUseNamespaceReexport:
+        'Module "{{source}}" is marked @import-as-namespace. Use: `export * as {{namespace}} from \'{{source}}\'`.',
+    },
+  },
+  create: (context) => {
+    const directiveCache = new Map();
+
+    const fileHasDirective = (filePath) => {
+      if (directiveCache.has(filePath)) {
+        return directiveCache.get(filePath);
+      }
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const result = DIRECTIVE_LINE_REGEX.test(content);
+        directiveCache.set(filePath, result);
+        return result;
+      } catch {
+        directiveCache.set(filePath, false);
+        return false;
+      }
+    };
+
+    const resolveRelativeImport = (source, currentFile) => {
+      if (!source.startsWith('.')) {
+        return null;
+      }
+      const dir = path.dirname(currentFile);
+      const resolved = path.resolve(dir, source);
+      for (const ext of TS_EXTENSIONS) {
+        const filePath = resolved + ext;
+        if (fs.existsSync(filePath)) {
+          return filePath;
+        }
+      }
+      for (const ext of TS_EXTENSIONS) {
+        const filePath = path.join(resolved, 'index' + ext);
+        if (fs.existsSync(filePath)) {
+          return filePath;
+        }
+      }
+      return null;
+    };
+
+    const namespaceFromSource = (source) => {
+      const parts = source.split('/');
+      const last = parts[parts.length - 1];
+      return last.replace(/\.\w+$/, '');
+    };
+
+    const buildImportFix = (fixer, node, source, expectedNamespace, context) => {
+      const fixes = [];
+      const importKeyword = node.importKind === 'type' ? 'import type' : 'import';
+      fixes.push(fixer.replaceText(node, `${importKeyword} * as ${expectedNamespace} from '${source}';`));
+
+      try {
+        const declaredVars = context.sourceCode.getDeclaredVariables(node);
+        for (const variable of declaredVars) {
+          for (const ref of variable.references) {
+            if (ref.identifier.range[0] >= node.range[0] && ref.identifier.range[1] <= node.range[1]) {
+              continue;
+            }
+            fixes.push(fixer.replaceText(ref.identifier, `${expectedNamespace}.${variable.name}`));
+          }
+        }
+      } catch {
+        // Scope analysis unavailable; fix import declaration only.
+      }
+
+      return fixes;
+    };
+
+    return {
+      Program: (node) => {
+        const comments = context.sourceCode.getAllComments();
+        const hasDirective = comments.some(
+          (comment) => comment.type === 'Line' && comment.value.trim() === DIRECTIVE_TEXT,
+        );
+        if (!hasDirective) {
+          return;
+        }
+        const filename = path.basename(context.getFilename());
+        const stem = filename.replace(/\.\w+$/, '');
+        if (!PASCAL_CASE_REGEX.test(stem)) {
+          context.report({
+            node,
+            messageId: 'filenameMustBePascalCase',
+            data: { filename },
+          });
+        }
+      },
+
+      ImportDeclaration: (node) => {
+        const source = String(node.source.value);
+        if (!source.startsWith('.')) {
+          return;
+        }
+        if (!node.specifiers || node.specifiers.length === 0) {
+          return;
+        }
+
+        const currentFile = context.getFilename();
+        const resolved = resolveRelativeImport(source, currentFile);
+        if (!resolved) {
+          return;
+        }
+        if (!fileHasDirective(resolved)) {
+          return;
+        }
+
+        const expectedNamespace = namespaceFromSource(source);
+
+        const isNamespaceImport =
+          node.specifiers.length === 1 && node.specifiers[0].type === 'ImportNamespaceSpecifier';
+
+        if (!isNamespaceImport) {
+          context.report({
+            node,
+            messageId: 'mustUseNamespaceImport',
+            data: { source, namespace: expectedNamespace },
+            fix: (fixer) => buildImportFix(fixer, node, source, expectedNamespace, context),
+          });
+          return;
+        }
+
+        const actual = node.specifiers[0].local.name;
+        const allowedNames = [expectedNamespace, expectedNamespace + 'Module'];
+        if (!allowedNames.includes(actual)) {
+          context.report({
+            node,
+            messageId: 'namespaceMustMatchFilename',
+            data: { actual, expected: expectedNamespace },
+            fix: (fixer) => {
+              const importKeyword = node.importKind === 'type' ? 'import type' : 'import';
+              return fixer.replaceText(node, `${importKeyword} * as ${expectedNamespace} from '${source}';`);
+            },
+          });
+        }
+      },
+
+      ExportNamedDeclaration: (node) => {
+        if (!node.source) {
+          return;
+        }
+        const source = String(node.source.value);
+        if (!source.startsWith('.')) {
+          return;
+        }
+
+        const currentFile = context.getFilename();
+        const resolved = resolveRelativeImport(source, currentFile);
+        if (!resolved) {
+          return;
+        }
+        if (!fileHasDirective(resolved)) {
+          return;
+        }
+
+        const expectedNamespace = namespaceFromSource(source);
+        const exportKeyword = node.exportKind === 'type' ? 'export type' : 'export';
+        context.report({
+          node,
+          messageId: 'mustUseNamespaceReexport',
+          data: { source, namespace: expectedNamespace },
+          fix: (fixer) => {
+            return fixer.replaceText(node, `${exportKeyword} * as ${expectedNamespace} from '${source}';`);
+          },
+        });
+      },
+
+      ExportAllDeclaration: (node) => {
+        if (!node.source) {
+          return;
+        }
+        const source = String(node.source.value);
+        if (!source.startsWith('.')) {
+          return;
+        }
+
+        const currentFile = context.getFilename();
+        const resolved = resolveRelativeImport(source, currentFile);
+        if (!resolved) {
+          return;
+        }
+        if (!fileHasDirective(resolved)) {
+          return;
+        }
+
+        const expectedNamespace = namespaceFromSource(source);
+
+        if (node.exported) {
+          const actual = node.exported.name;
+          const allowedNames = [expectedNamespace, expectedNamespace + 'Module'];
+          if (!allowedNames.includes(actual)) {
+            context.report({
+              node,
+              messageId: 'namespaceMustMatchFilename',
+              data: { actual, expected: expectedNamespace },
+              fix: (fixer) => {
+                return fixer.replaceText(node, `export * as ${expectedNamespace} from '${source}';`);
+              },
+            });
+          }
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: 'mustUseNamespaceReexport',
+          data: { source, namespace: expectedNamespace },
+          fix: (fixer) => {
+            return fixer.replaceText(node, `export * as ${expectedNamespace} from '${source}';`);
+          },
+        });
+      },
+    };
+  },
+};

package/rules/no-bare-dot-imports.js

@@ -0,0 +1,55 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+/**
+ * ESLint rule to prevent bare "." or ".." imports.
+ * These imports are ambiguous as they don't explicitly show which file is being imported.
+ *
+ * @example
+ * // ❌ Bad
+ * import { foo } from '.';
+ * import { bar } from '..';
+ *
+ * // ✅ Good
+ * import { foo } from './index';
+ * import { bar } from '../index';
+ */
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow bare "." or ".." in import paths',
+      category: 'Best Practices',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      bareDotImport: 'Use explicit path instead of bare "{{source}}". Consider "{{suggestion}}" instead.',
+    },
+  },
+  create: (context) => {
+    return {
+      ImportDeclaration: (node) => {
+        const source = node.source.value;
+
+        // Check if the import is exactly "." or ".."
+        if (source === '.' || source === '..') {
+          context.report({
+            node: node.source,
+            messageId: 'bareDotImport',
+            data: {
+              source,
+              suggestion: source === '.' ? './index' : '../index',
+            },
+            fix: (fixer) => {
+              const newSource = source === '.' ? './index' : '../index';
+              return fixer.replaceText(node.source, `'${newSource}'`);
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-effect-run-promise.js

@@ -0,0 +1,52 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+'use strict';
+
+/**
+ * ESLint rule to prevent usage of Effect.runPromise and Effect.runPromiseExit,
+ * and suggest runAndForwardErrors instead.
+ * @example
+ * // bad
+ * await Effect.runPromise(myEffect);
+ * await Effect.runPromiseExit(myEffect);
+ *
+ * // good
+ * await runAndForwardErrors(myEffect);
+ */
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow Effect.runPromise; suggest runAndForwardErrors instead.',
+      recommended: true,
+    },
+    messages: {
+      noRunPromise: 'Use runAndForwardErrors from @dxos/effect instead of Effect.runPromise.',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Check if this is Effect.runPromise or Effect.runPromiseExit
+        const isEffectMethod =
+          node.callee.type === 'MemberExpression' &&
+          node.callee.object.type === 'Identifier' &&
+          node.callee.object.name === 'Effect' &&
+          node.callee.property.type === 'Identifier';
+
+        if (isEffectMethod) {
+          const methodName = node.callee.property.name;
+          if (methodName === 'runPromise') {
+            context.report({
+              node,
+              messageId: 'noRunPromise',
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/translation-key-format.js

@@ -0,0 +1,443 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+'use strict';
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+/**
+ * Valid type suffixes for translation keys.
+ */
+const VALID_SUFFIXES = [
+  'label',
+  'message',
+  'placeholder',
+  'title',
+  'description',
+  'heading',
+  'alt',
+  'button',
+  'name',
+  'value',
+  'icon',
+  'menu',
+];
+
+/**
+ * Plural suffixes appended by i18next.
+ */
+const PLURAL_SUFFIXES = ['_zero', '_one', '_other'];
+
+/**
+ * Strip i18next plural suffix from a key.
+ */
+const stripPluralSuffix = (key) => {
+  for (const suffix of PLURAL_SUFFIXES) {
+    if (key.endsWith(suffix)) {
+      return key.slice(0, -suffix.length);
+    }
+  }
+  return key;
+};
+
+/**
+ * Get the plural suffix if present.
+ */
+const getPluralSuffix = (key) => {
+  for (const suffix of PLURAL_SUFFIXES) {
+    if (key.endsWith(suffix)) {
+      return suffix;
+    }
+  }
+  return '';
+};
+
+/**
+ * Check if a key has a valid type suffix (after stripping plural suffix).
+ * Only dot-separated suffixes are considered valid (e.g., 'foo.label').
+ */
+const hasValidSuffix = (key) => {
+  const base = stripPluralSuffix(key);
+  return VALID_SUFFIXES.some((suffix) => {
+    return base === suffix || base.endsWith(`.${suffix}`);
+  });
+};
+
+/**
+ * Check if a key has a suffix joined by hyphen instead of dot (e.g., 'plugin-name').
+ * Returns the corrected key if fixable, null otherwise.
+ */
+const fixHyphenatedSuffix = (key) => {
+  const pluralSuffix = getPluralSuffix(key);
+  const base = stripPluralSuffix(key);
+  for (const suffix of VALID_SUFFIXES) {
+    if (base.endsWith(`-${suffix}`) && base.length > suffix.length + 1) {
+      const prefix = base.slice(0, -(suffix.length + 1));
+      return `${prefix}.${suffix}${pluralSuffix}`;
+    }
+  }
+  return null;
+};
+
+/**
+ * Check if a key uses dot.kebab-case format (no spaces).
+ */
+const isDotNotation = (key) => {
+  const base = stripPluralSuffix(key);
+  return !base.includes(' ');
+};
+
+/**
+ * Convert a space-separated key to dot.kebab-case format.
+ */
+const toDotNotation = (key) => {
+  const pluralSuffix = getPluralSuffix(key);
+  const base = stripPluralSuffix(key);
+  const words = base.split(' ');
+
+  if (words.length <= 1) {
+    return key;
+  }
+
+  const lastWord = words[words.length - 1];
+  const isLastWordSuffix = VALID_SUFFIXES.includes(lastWord);
+
+  if (isLastWordSuffix) {
+    const pathWords = words.slice(0, -1);
+    const kebab = pathWords.join('-');
+    return `${kebab}.${lastWord}${pluralSuffix}`;
+  }
+
+  // No valid suffix — kebab-case everything.
+  const kebab = words.join('-');
+  return `${kebab}${pluralSuffix}`;
+};
+
+// --- Key validation: resolve meta.id and load translations ---
+
+/** Cache: pluginDir → { metaId, keys } */
+const pluginCache = new Map();
+
+/**
+ * Walk up from a file path to find the package root (directory containing src/translations.ts).
+ */
+const findPackageDir = (filePath) => {
+  let dir = dirname(filePath);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, 'src/translations.ts'))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return null;
+};
+
+/**
+ * Resolve the namespace identifier for a package.
+ * Plugins use meta.id from src/meta.ts.
+ * UI packages use translationKey from src/translations.ts.
+ */
+const resolveNamespace = (packageDir) => {
+  // Try plugin pattern: src/meta.ts with id field.
+  const metaPath = join(packageDir, 'src/meta.ts');
+  if (existsSync(metaPath)) {
+    const content = readFileSync(metaPath, 'utf-8');
+    const match = content.match(/id:\s*['"]([^'"]+)['"]/);
+    if (match) {
+      return { namespace: match[1], source: 'meta.id' };
+    }
+  }
+
+  // Try UI package pattern: export const translationKey = '...'.
+  const translationsPath = join(packageDir, 'src/translations.ts');
+  if (existsSync(translationsPath)) {
+    const content = readFileSync(translationsPath, 'utf-8');
+    const match = content.match(/export\s+const\s+translationKey\s*=\s*['"]([^'"]+)['"]/);
+    if (match) {
+      return { namespace: match[1], source: 'translationKey' };
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Extract translation keys for the primary namespace from a translations.ts file.
+ * Handles both [meta.id]: { ... } and [translationKey]: { ... } patterns.
+ */
+const readTranslationKeys = (packageDir, nsSource) => {
+  const keys = new Set();
+  const translationsPath = join(packageDir, 'src/translations.ts');
+  if (!existsSync(translationsPath)) {
+    return keys;
+  }
+
+  const content = readFileSync(translationsPath, 'utf-8');
+  const lines = content.split('\n');
+  let inBlock = false;
+  let braceDepth = 0;
+
+  // Match the namespace block header based on the source pattern.
+  const blockPattern = nsSource === 'meta.id' ? /\[meta\.id\]\s*:\s*\{/ : /\[translationKey\]\s*:\s*\{/;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (!inBlock && trimmed.match(blockPattern)) {
+      inBlock = true;
+      braceDepth = 1;
+      continue;
+    }
+
+    if (inBlock) {
+      for (const ch of trimmed) {
+        if (ch === '{') {
+          braceDepth++;
+        }
+        if (ch === '}') {
+          braceDepth--;
+        }
+      }
+
+      const keyMatch = trimmed.match(/^['"]([^'"]+)['"]\s*:/);
+      if (keyMatch && braceDepth >= 1) {
+        keys.add(keyMatch[1]);
+      }
+
+      if (braceDepth <= 0) {
+        inBlock = false;
+      }
+    }
+  }
+
+  return keys;
+};
+
+/**
+ * Get package info (namespace + valid keys) for a file, with caching.
+ */
+const getPackageInfo = (filePath) => {
+  const packageDir = findPackageDir(filePath);
+  if (!packageDir) {
+    return null;
+  }
+
+  if (pluginCache.has(packageDir)) {
+    return pluginCache.get(packageDir);
+  }
+
+  const nsInfo = resolveNamespace(packageDir);
+  if (!nsInfo) {
+    pluginCache.set(packageDir, null);
+    return null;
+  }
+
+  const keys = readTranslationKeys(packageDir, nsInfo.source);
+  const info = { namespace: nsInfo.namespace, nsSource: nsInfo.source, keys };
+  pluginCache.set(packageDir, info);
+  return info;
+};
+
+export default {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description:
+        'Enforce translation key format: dot.kebab-case with required type suffix. Validates keys exist in translations.',
+    },
+    messages: {
+      missingSuffix: 'Invalid translation key: "{{key}}"',
+      useDotsNotSpaces: 'Translation key "{{key}}" should use dot.kebab-case format. Suggested: "{{suggested}}".',
+      undefinedKey: 'Translation key "{{key}}" is not defined in translations for namespace "{{namespace}}".',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          suffixes: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const suffixes = options.suffixes || VALID_SUFFIXES;
+    const filename =
+      context.filename || (context.getFilename && context.getFilename()) || context.physicalFilename || '';
+
+    // Check source text once to determine if this is a translation-aware file.
+    const sourceText = (context.sourceCode || context.getSourceCode()).text;
+    const usesTranslation = sourceText.includes('useTranslation');
+    const usesStaticNamespace =
+      sourceText.includes('useTranslation(meta.id)') || sourceText.includes('useTranslation(translationKey)');
+
+    // Resolve package info for this file (works for both plugins and UI packages).
+    const packageInfo = getPackageInfo(filename);
+
+    /**
+     * Check a string literal node that represents a translation key.
+     * @param {boolean} isDefinition - true for keys in translations.ts definitions.
+     */
+    const checkKeyFormat = (node, key, isDefinition = false) => {
+      // Check 1: Must use dot notation (no spaces).
+      if (!isDotNotation(key)) {
+        const suggested = toDotNotation(key);
+        context.report({
+          node,
+          messageId: 'useDotsNotSpaces',
+          data: { key, suggested },
+          fix: (fixer) => fixer.replaceText(node, `'${suggested}'`),
+        });
+        return;
+      }
+
+      // Check 2: Suffix joined by hyphen instead of dot (e.g., 'plugin-name' → 'plugin.name').
+      const fixedKey = fixHyphenatedSuffix(key);
+      if (fixedKey) {
+        context.report({
+          node,
+          messageId: 'useDotsNotSpaces',
+          data: { key, suggested: fixedKey },
+          fix: (fixer) => fixer.replaceText(node, `'${fixedKey}'`),
+        });
+        return;
+      }
+
+      // Check 3: Must end with a valid suffix (definitions only).
+      if (isDefinition && !hasValidSuffix(key)) {
+        context.report({
+          node,
+          messageId: 'missingSuffix',
+          data: { key, suffixes: suffixes.join(', ') },
+        });
+      }
+    };
+
+    /**
+     * Check that a key exists in the package's translations.
+     */
+    const checkKeyExists = (node, key, hasNsOverride) => {
+      // Only check if we resolved the package and the file uses a static namespace.
+      if (!packageInfo || !usesStaticNamespace || hasNsOverride) {
+        return;
+      }
+
+      // Check exact key, then check plural variants (i18next resolves 'foo.label' with { count } to 'foo.label_one'/'foo.label_other').
+      const hasPluralVariant = PLURAL_SUFFIXES.some((suffix) => packageInfo.keys.has(key + suffix));
+      if (!packageInfo.keys.has(key) && !hasPluralVariant) {
+        context.report({
+          node,
+          messageId: 'undefinedKey',
+          data: { key, namespace: packageInfo.namespace },
+        });
+      }
+    };
+
+    return {
+      // t('some key') or t('some key', { ns: ... }).
+      // Only fires in files that use useTranslation.
+      CallExpression(node) {
+        if (
+          !usesTranslation ||
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 't' ||
+          node.arguments.length < 1 ||
+          node.arguments[0].type !== 'Literal' ||
+          typeof node.arguments[0].value !== 'string'
+        ) {
+          return;
+        }
+
+        const key = node.arguments[0].value;
+
+        // Check format.
+        checkKeyFormat(node.arguments[0], key);
+
+        // Check if there's an ns override in the second argument.
+        let hasNsOverride = false;
+        if (node.arguments.length >= 2 && node.arguments[1].type === 'ObjectExpression') {
+          hasNsOverride = node.arguments[1].properties.some(
+            (prop) =>
+              prop.key &&
+              ((prop.key.type === 'Identifier' && prop.key.name === 'ns') ||
+                (prop.key.type === 'Literal' && prop.key.value === 'ns')),
+          );
+        }
+
+        // Check existence.
+        checkKeyExists(node.arguments[0], key, hasNsOverride);
+      },
+
+      // Label tuples: ['key', { ns: meta.id, ... }]
+      // Matches ArrayExpression with a string literal first element and an object with an `ns` property.
+      ArrayExpression(node) {
+        if (
+          node.elements.length >= 2 &&
+          node.elements[0] &&
+          node.elements[0].type === 'Literal' &&
+          typeof node.elements[0].value === 'string' &&
+          node.elements[1] &&
+          node.elements[1].type === 'ObjectExpression' &&
+          node.elements[1].properties.some(
+            (prop) =>
+              prop.key &&
+              ((prop.key.type === 'Identifier' && prop.key.name === 'ns') ||
+                (prop.key.type === 'Literal' && prop.key.value === 'ns')),
+          )
+        ) {
+          const key = node.elements[0].value;
+
+          // Check format.
+          checkKeyFormat(node.elements[0], key);
+
+          // Check existence (determine if ns points to the package's own namespace).
+          const nsProp = node.elements[1].properties.find(
+            (prop) =>
+              prop.key &&
+              ((prop.key.type === 'Identifier' && prop.key.name === 'ns') ||
+                (prop.key.type === 'Literal' && prop.key.value === 'ns')),
+          );
+          const isOwnNamespace =
+            nsProp &&
+            nsProp.value &&
+            ((nsProp.value.type === 'MemberExpression' &&
+              nsProp.value.object.type === 'Identifier' &&
+              nsProp.value.object.name === 'meta' &&
+              nsProp.value.property.type === 'Identifier' &&
+              nsProp.value.property.name === 'id') ||
+              (nsProp.value.type === 'Identifier' && nsProp.value.name === 'translationKey'));
+          checkKeyExists(node.elements[0], key, !isOwnNamespace);
+        }
+      },
+
+      // Property keys in translations.ts files.
+      // Guard: only check files whose source contains the translations export pattern.
+      Property(node) {
+        if (!sourceText.includes('satisfies Resource[]')) {
+          return;
+        }
+
+        if (
+          node.key.type === 'Literal' &&
+          typeof node.key.value === 'string' &&
+          node.value.type === 'Literal' &&
+          typeof node.value.value === 'string'
+        ) {
+          checkKeyFormat(node.key, node.key.value, true);
+        }
+      },
+    };
+  },
+};