ai-codebase-registry 1.0.0

package/lib/core/registry.mjs

@@ -0,0 +1,222 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:registry
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity complex
+ * @token-budget 300
+ * @purpose Main Registry class — loads registry JSON and provides query/impact/resolve APIs
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Created Registry class with query, impact, resolve APIs
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Registry provides a programmatic query API over the generated registry files.
+ *
+ * Usage:
+ *   const registry = await Registry.load('./_registry');
+ *   const tripHooks = registry.query({ domain: 'trip', type: 'hook' });
+ *   const impact = registry.impact('functions/src/services/projectionService.ts');
+ */
+export class Registry {
+  constructor(data) {
+    this._manifest = data.manifest;
+    this._deps = data.deps;
+    this._semanticIds = data.semanticIds;
+    this._sideEffects = data.sideEffects;
+    this._relationships = data.relationships;
+    this._routes = data.routes;
+  }
+
+  /**
+   * Load registry from a directory containing JSON files.
+   * @param {string} registryDir - Path to _registry/ directory
+   * @returns {Registry}
+   */
+  static load(registryDir) {
+    const read = (name) => {
+      try {
+        return JSON.parse(readFileSync(join(registryDir, name), 'utf-8'));
+      } catch {
+        return null;
+      }
+    };
+
+    return new Registry({
+      manifest: read('manifest.json'),
+      deps: read('deps.json'),
+      semanticIds: read('semantic-ids.json'),
+      sideEffects: read('side-effects.json'),
+      relationships: read('relationships.json'),
+      routes: read('routes.json'),
+    });
+  }
+
+  /** Get the raw manifest data */
+  get manifest() { return this._manifest?.files || {}; }
+
+  /** Get the raw deps graph */
+  get deps() { return this._deps?.graph || {}; }
+
+  /** Get the raw semantic IDs map */
+  get semanticIds() { return this._semanticIds?.ids || {}; }
+
+  /** Get the raw side-effects data */
+  get sideEffects() { return this._sideEffects?.effects || {}; }
+
+  /** Get the raw routes data */
+  get routes() { return this._routes?.routes || {}; }
+
+  /**
+   * Query manifest files by domain and/or type.
+   * @param {{ domain?: string, type?: string }} filters
+   * @returns {{ path: string, meta: object }[]}
+   */
+  query(filters = {}) {
+    const results = [];
+    for (const [path, meta] of Object.entries(this.manifest)) {
+      if (filters.domain && meta.domain !== filters.domain) continue;
+      if (filters.type && meta.type !== filters.type) continue;
+      results.push({ path, ...meta });
+    }
+    return results;
+  }
+
+  /**
+   * Resolve a semantic ID to a file path.
+   * @param {string} semanticId - e.g., 'hook:trip:diary-entries'
+   * @returns {string|null} File path or null
+   */
+  resolve(semanticId) {
+    return this.semanticIds[semanticId] || null;
+  }
+
+  /**
+   * Get full metadata for a semantic ID.
+   * @param {string} semanticId
+   * @returns {object|null}
+   */
+  resolveWithMeta(semanticId) {
+    const path = this.resolve(semanticId);
+    if (!path) return null;
+    return { path, ...this.manifest[path] };
+  }
+
+  /**
+   * Get direct consumers (importedBy) for a file.
+   * @param {string} filePath
+   * @returns {string[]}
+   */
+  consumers(filePath) {
+    return this.deps[filePath]?.importedBy || [];
+  }
+
+  /**
+   * Get direct dependencies (imports) for a file.
+   * @param {string} filePath
+   * @returns {string[]}
+   */
+  dependencies(filePath) {
+    return this.deps[filePath]?.imports || [];
+  }
+
+  /**
+   * Comprehensive impact analysis for changing a file.
+   * Returns direct consumers, transitive consumers (2 levels), change impact rules, and side-effects.
+   *
+   * @param {string} filePath
+   * @returns {object}
+   */
+  impact(filePath) {
+    const direct = this.consumers(filePath);
+
+    // Transitive consumers (2 levels deep)
+    const transitiveSet = new Set();
+    for (const consumer of direct) {
+      const level2 = this.consumers(consumer);
+      for (const t of level2) {
+        if (t !== filePath && !direct.includes(t)) {
+          transitiveSet.add(t);
+        }
+      }
+    }
+
+    // Check change_impact_rules from relationships.json
+    const impactRules = [];
+    const cir = this._relationships?.change_impact_rules;
+    if (Array.isArray(cir)) {
+      for (const rule of cir) {
+        if (rule.when && filePath.includes(rule.when.replace(/\*/g, ''))) {
+          impactRules.push(rule);
+        }
+      }
+    }
+
+    // Get side-effects chain
+    const meta = this.manifest[filePath];
+    const semanticId = meta?.id;
+    const sideEffectEntry = semanticId ? this.sideEffects[semanticId] : null;
+
+    return {
+      file: filePath,
+      directConsumers: direct,
+      transitiveConsumers: [...transitiveSet],
+      changeImpactRules: impactRules,
+      sideEffects: sideEffectEntry?.sideEffects || [],
+    };
+  }
+
+  /**
+   * Get side-effects chain for a semantic ID.
+   * @param {string} semanticId
+   * @returns {object|null}
+   */
+  sideEffectChain(semanticId) {
+    return this.sideEffects[semanticId] || null;
+  }
+
+  /**
+   * Find orphaned routes (no nav entry point).
+   * @returns {{ path: string, component: string }[]}
+   */
+  orphanedRoutes() {
+    const results = [];
+    for (const [routePath, routeData] of Object.entries(this.routes)) {
+      if (routeData.nav_entry_points?.status === 'orphaned') {
+        results.push({ path: routePath, component: routeData.component, file: routeData.file });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Get coverage statistics.
+   * @returns {object}
+   */
+  coverage() {
+    const files = Object.entries(this.manifest);
+    const total = files.length;
+    let withId = 0, withSideEffects = 0, withPurpose = 0;
+
+    for (const [, meta] of files) {
+      if (meta.id) withId++;
+      if (meta.sideEffects !== undefined) withSideEffects++;
+      if (meta.purpose) withPurpose++;
+    }
+
+    return {
+      totalFiles: total,
+      withId: { count: withId, pct: ((withId / total) * 100).toFixed(1) },
+      withSideEffects: { count: withSideEffects, pct: ((withSideEffects / total) * 100).toFixed(1) },
+      withPurpose: { count: withPurpose, pct: ((withPurpose / total) * 100).toFixed(1) },
+      missingId: files.filter(([, m]) => !m.id).map(([p]) => p),
+      missingSideEffects: files.filter(([, m]) => m.sideEffects === undefined).map(([p]) => p),
+    };
+  }
+}

package/lib/core/semantic-id.mjs

@@ -0,0 +1,56 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:semantic-id
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity moderate
+ * @token-budget 120
+ * @purpose Generates and resolves semantic IDs (type:domain:kebab-name) for codebase entities
+ *
+ * @filechangelog
+ * @changelog 2026-02-23T10:00 [feat] [Claude Opus 4.6] Add Swift suffix stripping (ViewModel, View, Service) for cleaner IDs
+ * @changelog 2026-02-22T16:00 [fix] [Claude Opus 4.6] Remove Context suffix stripping and index-file handling to align with local deriveSemanticId
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs
+ */
+
+import { basename, extname } from 'path';
+
+/** Suffixes to strip from filenames when generating semantic IDs, ordered longest-first */
+const SUFFIX_STRIP = ['ViewModel', 'Page', 'View', 'Service'];
+
+/**
+ * Generate a semantic ID from file metadata.
+ * Format: {type}:{domain}:{kebab-filename}
+ *
+ * @param {string} relPath - Relative file path
+ * @param {{ type: string, domain: string }} meta - File metadata with type and domain
+ * @returns {string} Semantic ID
+ */
+export function generateSemanticId(relPath, meta) {
+  const name = basename(relPath);
+  const ext = extname(name);
+  let nameNoExt = name.replace(ext, '');
+
+  // Strip common prefixes (hooks: useXxx)
+  if (nameNoExt.startsWith('use') && nameNoExt[3] === nameNoExt[3]?.toUpperCase()) {
+    nameNoExt = nameNoExt.slice(3);
+  }
+
+  // Strip common suffixes (Page, View, ViewModel, Service)
+  for (const suffix of SUFFIX_STRIP) {
+    if (nameNoExt.endsWith(suffix) && nameNoExt.length > suffix.length) {
+      nameNoExt = nameNoExt.slice(0, -suffix.length);
+      break; // Only strip one suffix
+    }
+  }
+
+  // Convert PascalCase/camelCase to kebab-case
+  const kebab = nameNoExt
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+    .toLowerCase();
+
+  return `${meta.type}:${meta.domain}:${kebab}`;
+}

package/lib/core/type-detector.mjs

@@ -0,0 +1,114 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:type-detector
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity moderate
+ * @token-budget 200
+ * @purpose Detects file type (hook, component, page, etc.) from file path — supports TypeScript and Swift conventions
+ *
+ * @filechangelog
+ * @changelog 2026-02-23T10:00 [feat] [Claude Opus 4.6] Add Swift-specific type detection rules (ViewModel, View, Service, Tests)
+ * @changelog 2026-02-22T16:00 [fix] [Claude Opus 4.6] Add missing /agents/ and /services/ rules for functions/src/ block
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs, made configurable
+ */
+
+import { basename, extname } from 'path';
+
+/**
+ * Detect file type from path for Swift files.
+ *
+ * @param {string} relPath - Relative file path
+ * @param {string} nameNoExt - Filename without extension
+ * @returns {string} Detected type
+ */
+function detectSwiftFileType(relPath, nameNoExt) {
+  // Test files
+  if (relPath.includes('Tests/') || nameNoExt.endsWith('Tests')) return 'test';
+
+  // ViewModel: XxxViewModel
+  if (nameNoExt.endsWith('ViewModel')) return 'viewmodel';
+
+  // Service: XxxService
+  if (nameNoExt.endsWith('Service') || relPath.includes('/Services/')) return 'service';
+
+  // View: XxxView (must come after ViewModel check)
+  if (nameNoExt.endsWith('View')) return 'view';
+
+  // Models directory
+  if (relPath.includes('/Models/')) return 'model';
+
+  // Theme directory
+  if (relPath.includes('/Theme/')) return 'config';
+
+  // Validators
+  if (nameNoExt.endsWith('Validator') || nameNoExt === 'Validators') return 'util';
+
+  // App entry point
+  if (nameNoExt.endsWith('App') || nameNoExt === 'AppDelegate') return 'config';
+
+  return 'module';
+}
+
+/**
+ * Detect file type from path using default heuristics.
+ *
+ * @param {string} relPath - Relative file path
+ * @returns {string} Detected type
+ */
+export function detectFileType(relPath) {
+  const name = basename(relPath);
+  const ext = extname(name);
+  const nameNoExt = name.replace(ext, '');
+
+  // Swift files use a dedicated detector
+  if (ext === '.swift') {
+    return detectSwiftFileType(relPath, nameNoExt);
+  }
+
+  // Test files
+  if (name.includes('.test.') || name.includes('.spec.')) return 'test';
+  if (relPath.includes('/e2e/') || relPath.includes('/__tests__/')) return 'test';
+
+  // Type definitions
+  if (name.includes('.types.') || relPath.includes('/types/') || name === 'types.ts') return 'types';
+
+  // Hooks: useXxx
+  if (nameNoExt.startsWith('use') && nameNoExt[3] === nameNoExt[3]?.toUpperCase()) return 'hook';
+
+  // Pages: XxxPage
+  if (nameNoExt.endsWith('Page')) return 'page';
+
+  // Contexts: XxxContext
+  if (nameNoExt.endsWith('Context')) return 'context';
+
+  // Services
+  if (nameNoExt.endsWith('Service') || relPath.includes('/services/')) return 'service';
+
+  // Layout components
+  if (relPath.includes('/components/layout/')) return 'layout';
+
+  // Backend-specific types
+  if (relPath.startsWith('functions/src/') || relPath.includes('/server/')) {
+    if (relPath.includes('operations') || relPath.includes('Operations')) return 'operations';
+    if (relPath.includes('triggers') || relPath.includes('Triggers')) return 'trigger';
+    if (relPath.includes('jobs') || relPath.includes('Jobs')) return 'job';
+    if (relPath.includes('/config/')) return 'config';
+    if (relPath.includes('/utils/') || relPath.includes('/helpers/')) return 'util';
+    if (relPath.includes('/agents/')) return 'module';
+    if (relPath.includes('/services/')) return 'service';
+    if (relPath.includes('/middleware/')) return 'module';
+    if (relPath.includes('/testing/')) return 'test';
+  }
+
+  // General patterns
+  if (relPath.includes('/utils/')) return 'util';
+  if (nameNoExt.endsWith('Config') || nameNoExt.endsWith('config')) return 'config';
+  if (nameNoExt === 'constants' || nameNoExt.endsWith('Constants')) return 'constants';
+  if (nameNoExt === 'index') return 'index';
+  if (ext === '.tsx') return 'component';
+
+  return 'module';
+}

package/lib/generators/deps.mjs

@@ -0,0 +1,55 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:gen-deps
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity moderate
+ * @token-budget 80
+ * @purpose Generates deps.json — forward and reverse dependency graph from import analysis
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs
+ */
+
+/**
+ * Build dependency graph from import relationships.
+ *
+ * @param {object} importGraph - Map of filePath → Set of imported file paths
+ * @returns {object} Dependency graph with imports and importedBy for each file
+ */
+export function generateDeps(importGraph) {
+  const depsGraph = {};
+
+  // Forward edges
+  for (const [filePath, importSet] of Object.entries(importGraph)) {
+    depsGraph[filePath] = {
+      imports: [...importSet].sort(),
+      importedBy: [],
+    };
+  }
+
+  // Reverse edges
+  for (const [filePath, importSet] of Object.entries(importGraph)) {
+    for (const target of importSet) {
+      if (depsGraph[target]) {
+        depsGraph[target].importedBy.push(filePath);
+      }
+    }
+  }
+
+  // Sort reverse edges
+  for (const deps of Object.values(depsGraph)) {
+    deps.importedBy.sort();
+  }
+
+  const edgeCount = Object.values(depsGraph).reduce((sum, d) => sum + d.imports.length, 0);
+
+  return {
+    generated: new Date().toISOString(),
+    nodeCount: Object.keys(depsGraph).length,
+    edgeCount,
+    graph: depsGraph,
+  };
+}

package/lib/generators/features.mjs

@@ -0,0 +1,58 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:gen-features
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity moderate
+ * @token-budget 80
+ * @purpose Generates features.json — groups manifest files by domain into feature inventory
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs
+ */
+
+/**
+ * Group manifest files by domain into a feature inventory.
+ *
+ * @param {object} manifest - File manifest
+ * @returns {object} Domain → file type buckets
+ */
+export function generateFeatures(manifest) {
+  const domains = {};
+
+  const TYPE_TO_BUCKET = {
+    component: 'components', hook: 'hooks', page: 'pages', context: 'contexts',
+    service: 'services', layout: 'layouts', types: 'types', util: 'utils',
+    operations: 'operations', trigger: 'triggers', job: 'jobs', test: 'tests',
+  };
+
+  for (const [relPath, meta] of Object.entries(manifest)) {
+    const domain = meta.domain;
+    if (!domains[domain]) {
+      domains[domain] = {};
+    }
+
+    const bucket = TYPE_TO_BUCKET[meta.type] || 'other';
+    if (!domains[domain][bucket]) {
+      domains[domain][bucket] = [];
+    }
+    domains[domain][bucket].push(relPath);
+  }
+
+  // Remove empty arrays
+  for (const domain of Object.values(domains)) {
+    for (const key of Object.keys(domain)) {
+      if (Array.isArray(domain[key]) && domain[key].length === 0) {
+        delete domain[key];
+      }
+    }
+  }
+
+  return {
+    generated: new Date().toISOString(),
+    domainCount: Object.keys(domains).length,
+    domains,
+  };
+}

package/lib/generators/index.mjs

@@ -0,0 +1,20 @@
+/**
+ * @ai-meta
+ * @id index:ai-agent-infra:generators-index
+ * @domain ai-agent-infra
+ * @type index
+ * @side-effects none
+ * @stability high
+ * @complexity trivial
+ * @token-budget 30
+ * @purpose Barrel export for all registry generators
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Created generators barrel export
+ */
+
+export { generateManifest } from './manifest.mjs';
+export { generateDeps } from './deps.mjs';
+export { generateSemanticIds } from './semantic-ids.mjs';
+export { generateSideEffects } from './side-effects.mjs';
+export { generateFeatures } from './features.mjs';

package/lib/generators/manifest.mjs

@@ -0,0 +1,128 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:gen-manifest
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity complex
+ * @token-budget 280
+ * @purpose Generates manifest.json — file metadata index with domain, type, imports, purpose from @ai-meta
+ *
+ * @filechangelog
+ * @changelog 2026-02-23T10:00 [feat] [Claude Opus 4.6] Add fieldMap + skipImportParsing options for multi-language support
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs
+ */
+
+import { readFileSync, statSync } from 'fs';
+import { parseAiMeta, normalizeType } from '../core/ai-meta-parser.mjs';
+import { detectDomain as defaultDetectDomain } from '../core/domain-detector.mjs';
+import { detectFileType } from '../core/type-detector.mjs';
+import { parseImports, createResolver } from '../parsers/imports-typescript.mjs';
+
+/**
+ * Build file manifest from discovered files.
+ *
+ * @param {{ fullPath: string, relPath: string }[]} allFiles
+ * @param {object} options
+ * @param {object} [options.aliasMap] - Import alias map
+ * @param {(relPath: string) => string} [options.detectDomain] - Custom domain detector
+ * @param {object} [options.fieldMap] - Field name normalization map for @ai-meta parsing
+ * @param {boolean} [options.skipImportParsing] - Skip TypeScript import parsing (for non-TS languages)
+ * @returns {{ manifest: object, importGraph: object, stats: object }}
+ */
+export function generateManifest(allFiles, options = {}) {
+  const aliasMap = options.aliasMap || {};
+  const detectDomain = options.detectDomain || defaultDetectDomain;
+  const fieldMap = options.fieldMap || {};
+  const skipImportParsing = options.skipImportParsing || false;
+
+  const allFilePathsSet = new Set(allFiles.map(f => f.relPath));
+  const resolveSpecifier = skipImportParsing ? null : createResolver(aliasMap, allFilePathsSet);
+
+  const manifest = {};
+  const importGraph = {};
+  let aiMetaCount = 0;
+  let purposeCount = 0;
+  let firestoreCount = 0;
+
+  for (const { fullPath, relPath } of allFiles) {
+    let content;
+    try {
+      content = readFileSync(fullPath, 'utf-8');
+    } catch (err) {
+      console.warn(`  Warning: Cannot read file: ${relPath} (${err.code || err.message})`);
+      continue;
+    }
+
+    const stat = statSync(fullPath);
+    const lineCount = content.split('\n').length;
+
+    const resolvedImports = [];
+    const rawSpecifiers = [];
+
+    if (!skipImportParsing) {
+      const rawImports = parseImports(content);
+      for (const spec of rawImports) {
+        const resolved = resolveSpecifier(spec, relPath);
+        if (resolved) resolvedImports.push(resolved);
+        if (spec.startsWith('.') || Object.keys(aliasMap).some(a => spec.startsWith(a))) {
+          rawSpecifiers.push(spec);
+        }
+      }
+    }
+
+    importGraph[relPath] = new Set(resolvedImports);
+
+    const aiMeta = parseAiMeta(content, { fieldMap });
+    if (aiMeta) aiMetaCount++;
+
+    const rawType = aiMeta?.type || detectFileType(relPath);
+    const finalType = normalizeType(rawType);
+
+    const entry = {
+      domain: aiMeta?.domain || detectDomain(relPath),
+      type: finalType,
+      imports: rawSpecifiers,
+      importedBy: [],
+      size: lineCount,
+      lastModified: stat.mtime.toISOString().split('T')[0],
+    };
+
+    if (aiMeta?.purpose) { entry.purpose = aiMeta.purpose; purposeCount++; }
+    if (aiMeta?.firestore) { entry.firestorePaths = aiMeta.firestore; firestoreCount++; }
+    if (aiMeta?.['depends-on']) { entry.curatedDeps = aiMeta['depends-on']; }
+    if (aiMeta?.id) { entry.id = aiMeta.id; }
+    if (aiMeta?.['side-effects'] !== undefined) { entry.sideEffects = aiMeta['side-effects']; }
+
+    manifest[relPath] = entry;
+  }
+
+  // Build reverse edges (only meaningful when import parsing is active)
+  if (!skipImportParsing) {
+    for (const [filePath, importSet] of Object.entries(importGraph)) {
+      for (const target of importSet) {
+        if (manifest[target]) {
+          manifest[target].importedBy.push(filePath);
+        }
+      }
+    }
+  }
+
+  // Sort importedBy
+  for (const entry of Object.values(manifest)) {
+    entry.importedBy.sort();
+  }
+
+  return {
+    manifest,
+    importGraph,
+    stats: {
+      totalFiles: allFiles.length,
+      aiMetaCount,
+      purposeCount,
+      firestoreCount,
+      coverage: `${aiMetaCount}/${allFiles.length} (${(aiMetaCount / allFiles.length * 100).toFixed(1)}%)`,
+    },
+  };
+}

package/lib/generators/semantic-ids.mjs

@@ -0,0 +1,43 @@
+/**
+ * @ai-meta
+ * @id module:ai-agent-infra:gen-semantic-ids
+ * @domain ai-agent-infra
+ * @type module
+ * @side-effects none
+ * @stability high
+ * @complexity trivial
+ * @token-budget 60
+ * @purpose Generates semantic-ids.json — maps semantic IDs to file paths for instant lookup
+ *
+ * @filechangelog
+ * @changelog 2026-02-22T14:00 [feat] [Claude Opus 4.6] Extracted from generate-registry.mjs
+ */
+
+import { generateSemanticId } from '../core/semantic-id.mjs';
+
+/**
+ * Generate semantic ID → file path mapping from manifest.
+ *
+ * @param {object} manifest - File manifest
+ * @returns {object} Semantic IDs registry
+ */
+export function generateSemanticIds(manifest) {
+  const ids = {};
+  let explicitCount = 0;
+  let derivedCount = 0;
+
+  for (const [relPath, meta] of Object.entries(manifest)) {
+    const semanticId = meta.id || generateSemanticId(relPath, meta);
+    ids[semanticId] = relPath;
+    if (meta.id) explicitCount++;
+    else derivedCount++;
+  }
+
+  return {
+    version: '1.0',
+    generated: new Date().toISOString(),
+    explicitCount,
+    derivedCount,
+    ids,
+  };
+}