wip(ui): extractor home cases, zh census reads the namespace

Claude-Session: https://claude.ai/code/session_01ADHkmRuDqEXC3CybUtz5d1
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

ui/packages/app-shell/src/views/metadata-admin/zh-base-term.i18n-13131.test.ts

@@ -11,6 +11,10 @@
  * question. Regex: the whole Latin word `base`, case-insensitive, matched in the
  * row VALUE only — keys, identifiers such as `baseObject` (no word boundary)
  * and comments are out of scope.
+ *
+ * The rows that moved into `@object-ui/i18n`'s `studio` namespace
+ * (objectstack#25922) are walked too, from the namespace's own `zh` catalogue,
+ * so the census still covers the whole designer table wherever a row lives.
  */
 
 import { describe, it, expect } from 'vitest';
@@ -19,6 +23,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 // @ts-expect-error — plain-JS shared helper, intentionally untyped (`allowJs: false`)
 import { maskComments } from '../../../../../scripts/js-comment-mask.mjs';
+import { loadStudioCatalogue } from '@object-ui/i18n/namespaces/studio';
 import { t } from './i18n';
 
 const mask: (source: string) => string = maskComments;
@@ -33,9 +38,12 @@ function zhRows(): Array<[string, string]> {
   const rows: Array<[string, string]> = [];
   const row = /'((?:[^'\\\n]|\\.)*)'\s*:\s*'((?:[^'\\\n]|\\.)*)'/g;
   for (const m of block.matchAll(row)) rows.push([m[1], m[2]]);
-  return rows;
+  return [...rows, ...Object.entries(studioZh)];
 }
 
+/** The namespace's `zh` rows (objectstack#25922), resident before any case runs. */
+const studioZh = await loadStudioCatalogue('zh');
+
 const BARE_BASE = /\bbase\b/i;
 
 describe('zh "base" (writable package) is translated — objectui#13131', () => {

ui/scripts/__tests__/check-i18n-dead-keys.test.ts

@@ -6,6 +6,8 @@ import { fileURLToPath } from 'node:url';
 
 import {
   ANALYSED_PACK_OBJECT_IMPORTERS,
+  DESIGNER_NAMESPACE_HOMES,
+  DESIGNER_NAMESPACE_SPECIFIER,
   DESIGNER_TABLE,
   collectDesignerKeys,
   collectIndirectTemplateHeads,
@@ -792,6 +794,62 @@ describe('collectDesignerKeys() — the optional second argument', () => {
   });
 });
 
+/**
+ * objectstack#25922 — the table's second home, the `studio` namespace. Its
+ * catalogues are read as members of the table they belong to, but only when the
+ * table module imports the namespace: the edge the runtime follows.
+ */
+describe('collectDesignerKeys() — the namespace homes', () => {
+  const [EN_HOME, ZH_HOME] = DESIGNER_NAMESPACE_HOMES;
+  const IMPORTING_TABLE = `import { studioString } from '${DESIGNER_NAMESPACE_SPECIFIER}';\n${DESIGNER_TABLE_FIXTURE}`;
+  const homes = (en: string, zh: string) => ({
+    [EN_HOME.file]: `const ${EN_HOME.decl}: Record<string, string> = { ${en} };\nexport default ${EN_HOME.decl};\n`,
+    [ZH_HOME.file]: `const ${ZH_HOME.decl}: Record<string, string> = { ${zh} };\nexport default ${ZH_HOME.decl};\n`,
+  });
+  const MOVED = homes("'designer.fx.moved': 'Moved'", "'designer.fx.moved': '已迁移'");
+
+  it('merges a home into its table when the table imports the namespace', () => {
+    const { tables, values } = collectDesignerKeys(designerRoot({ [DESIGNER_TABLE]: IMPORTING_TABLE, ...MOVED }), {
+      withValues: true,
+    });
+    expect(tables.get('ENGINE_STRINGS_EN')!.size).toBe(10);
+    expect(tables.get('ENGINE_STRINGS_ZH')!.has('designer.fx.moved')).toBe(true);
+    expect(values!.get('ENGINE_STRINGS_ZH')!.get('designer.fx.moved')).toBe('已迁移');
+  });
+
+  it('reads no home when the table does not import the namespace, even if the files exist', () => {
+    const { tables } = collectDesignerKeys(designerRoot(MOVED));
+    expect(tables.get('ENGINE_STRINGS_EN')!.has('designer.fx.moved')).toBe(false);
+  });
+
+  it('throws when the table imports the namespace and a home cannot be read', () => {
+    expect(() => collectDesignerKeys(designerRoot({ [DESIGNER_TABLE]: IMPORTING_TABLE }))).toThrow(/cannot be read/);
+  });
+
+  it('throws on a key in both homes', () => {
+    const root = designerRoot({
+      [DESIGNER_TABLE]: IMPORTING_TABLE,
+      ...homes("'engine.fx.dead': 'Copy'", "'engine.fx.dead': '副本'"),
+    });
+    expect(() => collectDesignerKeys(root)).toThrow(/exactly one home/);
+  });
+
+  it('a caller that passes `source` reads homes through `readHome`, or throws', () => {
+    const root = designerRoot(MOVED);
+    expect(() => collectDesignerKeys(root, { source: IMPORTING_TABLE })).toThrow(/readHome/);
+    const read = collectDesignerKeys(root, {
+      source: IMPORTING_TABLE,
+      readHome: (file: string) => fs.readFileSync(path.join(root, file), 'utf8'),
+    });
+    expect(read.corpus.has('designer.fx.moved')).toBe(true);
+  });
+
+  it("the dead-keys sweep does not read a home's own literal as a reader of its keys", () => {
+    const result = sweepDesignerTable(designerRoot({ [DESIGNER_TABLE]: IMPORTING_TABLE, ...MOVED }));
+    expect(keysOf(result.confirmed)).toContain('designer.fx.moved');
+  });
+});
+
 describe('sweepDesignerTable()', () => {
   it('excludes a key spelled as a literal at a call site', () => {
     const result = sweepDesignerTable(designerRoot());