arkgate 2.8.2 → 2.9.0

package/bin/lib/agent-gates.mjs

@@ -20,8 +20,9 @@ import {
   DEFAULT_DOMAIN_FORBIDDEN_GLOBALS,
   DEFAULT_RULES,
   createElevenLayerConfig,
-  applyFrameworkLayoutOverlays
+  applyFrameworkLayoutOverlays,
 } from '../ark-shared.mjs';
+import { CORE_LAYER_NAMES } from './core-ratchet.mjs';
 import {
   assessCodexHomeMcp,
   codexArkBlockHasPreferredBin,
@@ -76,6 +77,97 @@ export function hasCheckArchitectureScript(root) {
   return Boolean(pkg?.scripts?.['check:architecture']);
 }
 
+/**
+ * Whether package.json scripts already expose a typecheck-like command.
+ * Shared by deploy-path quality + typecheck bootstrap (single definition).
+ * @param {Record<string, unknown>|null|undefined} scripts
+ */
+export function packageScriptsHaveTypecheck(scripts) {
+  if (!scripts || typeof scripts !== 'object') return false;
+  return Boolean(
+    (typeof scripts.typecheck === 'string' && scripts.typecheck.trim()) ||
+      (typeof scripts['type-check'] === 'string' && scripts['type-check'].trim()) ||
+      (typeof scripts['check:types'] === 'string' && scripts['check:types'].trim()) ||
+      (typeof scripts.tsc === 'string' && /\btsc\b/.test(scripts.tsc))
+  );
+}
+
+/**
+ * Root package (and shallow nested packages) already have a typecheck script.
+ * Does not scan CI or framework configs — only package.json scripts.
+ * @param {string} root
+ */
+export function treeHasTypecheckScript(root) {
+  const pkg = readPackageJson(root);
+  if (packageScriptsHaveTypecheck(pkg?.scripts)) return true;
+  try {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const candidates = [path.join(root, entry.name)];
+      try {
+        for (const child of fs.readdirSync(path.join(root, entry.name), { withFileTypes: true })) {
+          if (child.isDirectory() && !child.name.startsWith('.')) {
+            candidates.push(path.join(root, entry.name, child.name));
+          }
+        }
+      } catch {
+        /* ignore */
+      }
+      for (const dir of candidates) {
+        const pj = path.join(dir, 'package.json');
+        if (!fs.existsSync(pj)) continue;
+        try {
+          const nested = JSON.parse(fs.readFileSync(pj, 'utf8'));
+          if (packageScriptsHaveTypecheck(nested.scripts)) return true;
+        } catch {
+          /* ignore */
+        }
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+  return false;
+}
+
+/**
+ * Add a conservative `typecheck` script when the host has a TS/JS project config
+ * but no typecheck-like script yet. Never overwrites an existing script.
+ *
+ * @param {string} root
+ * @param {{ write?: boolean }} [opts]
+ * @returns {{
+ *   changed: boolean,
+ *   reason: 'added' | 'already' | 'no-tsconfig' | 'no-package-json',
+ *   script?: string,
+ * }}
+ */
+export function ensureTypecheckScript(root, opts = {}) {
+  const write = opts.write !== false;
+  const hasTsconfig =
+    fs.existsSync(path.join(root, 'tsconfig.json')) ||
+    fs.existsSync(path.join(root, 'jsconfig.json'));
+  if (!hasTsconfig) return { changed: false, reason: 'no-tsconfig' };
+
+  const pkgPath = path.join(root, 'package.json');
+  if (!fs.existsSync(pkgPath)) return { changed: false, reason: 'no-package-json' };
+
+  if (treeHasTypecheckScript(root)) {
+    return { changed: false, reason: 'already' };
+  }
+
+  const pkg = readPackageJson(root) || {};
+  const scripts =
+    pkg.scripts && typeof pkg.scripts === 'object' ? { ...pkg.scripts } : {};
+  const script = 'tsc --noEmit';
+  scripts.typecheck = script;
+  if (write) {
+    const next = { ...pkg, scripts };
+    fs.writeFileSync(pkgPath, `${JSON.stringify(next, null, 2)}\n`);
+  }
+  return { changed: true, reason: 'added', script };
+}
+
 export const REQUIRED_GATE_FILES = [
   'AGENTS.md',
   '.mcp.json',
@@ -945,14 +1037,6 @@ export function brokenMcpGateFiles(root) {
   return bad;
 }
 
-/** Core layers whose optionality matters once they match files (presets share these names). */
-const CORE_LAYER_NAMES = new Set([
-  'DomainModel',
-  'ApplicationOrchestration',
-  'PresentationAdapters',
-  'PersistenceAdapters',
-]);
-
 /**
  * Production deploy path quality (universal — any consumer repo).
  * Detects when the production build host runs ESLint / typecheck as part of
@@ -1005,17 +1089,9 @@ export function detectDeployPathQuality(root) {
           (typeof s['lint:ci'] === 'string' && s['lint:ci'].trim()) ||
           (typeof s['check:lint'] === 'string' && s['check:lint'].trim()))
     );
-  const scriptHasTypecheck = (s) =>
-    Boolean(
-      s &&
-        ((typeof s.typecheck === 'string' && s.typecheck.trim()) ||
-          (typeof s['type-check'] === 'string' && s['type-check'].trim()) ||
-          (typeof s['check:types'] === 'string' && s['check:types'].trim()) ||
-          (typeof s.tsc === 'string' && /\btsc\b/.test(s.tsc)))
-    );
 
   let hasLintScript = scriptHasLint(scripts);
-  let hasTypecheckScript = scriptHasTypecheck(scripts);
+  let hasTypecheckScript = packageScriptsHaveTypecheck(scripts);
   const packageLintScripts = [];
   // Monorepo: package-level scripts count (apps/web, packages/ui, …).
   try {
@@ -1042,7 +1118,7 @@ export function detectDeployPathQuality(root) {
             hasLintScript = true;
             packageLintScripts.push(path.relative(root, dir).split(path.sep).join('/'));
           }
-          if (scriptHasTypecheck(ns)) hasTypecheckScript = true;
+          if (packageScriptsHaveTypecheck(ns)) hasTypecheckScript = true;
           const nd = {
             ...(nested.dependencies || {}),
             ...(nested.devDependencies || {}),
@@ -1289,7 +1365,7 @@ export function collectAdoptionGaps(root, config, coverage) {
         id: `core-optional-${layer.name}`,
         severity: 'info',
         message: `Core layer ${layer.name} has ${files} file(s) but is still optional: true — contract is weaker than the tree`,
-        fix: `Edit ark.config.json: remove optional on ${layer.name} (or set false), then ${arkCommand(root, 'ark-check', '--strict-config')}`,
+        fix: `${arkCommand(root, 'ark-check', '--ratchet-cores')} (when architecture is green: 0 active violations)`,
       });
     }
   }
@@ -1625,7 +1701,15 @@ export function runInstallAgentGates(args) {
   // overwrite (they track the package). The gate/instruction files (AGENTS.md,
   // settings.json, CI workflow, rules) are the ones users customize, so a plain
   // `--force` clobbers them — this is the safe way to pick up new skill versions.
+  // Do not mutate package.json under --skills-only (typecheck bootstrap is gates/CI).
   if (!args.skillsOnly) {
+    // Bootstrap typecheck before CI template so generated workflow includes the step.
+    const typecheckBootstrap = ensureTypecheckScript(root, { write: true });
+    if (typecheckBootstrap.changed && !args.json) {
+      console.log(
+        `Added package.json script "typecheck": "${typecheckBootstrap.script}" (tsconfig present; local/CI parity).`
+      );
+    }
     // Base gates: tool-agnostic contract + CI backstop, always written.
     templates.push(['AGENTS.md', agentInstructions(root)]);
     templates.push(['.mcp.json', mcpJson(root)]);

package/bin/lib/architecture-scan.mjs

@@ -237,10 +237,16 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           importGraph.get(relFile).add(relTarget);
         }
       }
-      const rule = targetLayer ? isBlocked(rules, sourceLayer, targetLayer) : undefined;
+      const relTarget = target ? normalize(path.relative(root, target)) : undefined;
+      const rule = targetLayer
+        ? isBlocked(rules, sourceLayer, targetLayer, {
+            fromPath: relFile,
+            toPath: relTarget,
+            layers: config.layers,
+          })
+        : undefined;
       if (rule) {
-        const relTarget = normalize(path.relative(root, target));
-        const targetCached = nextCacheFiles[relTarget];
+        const targetCached = relTarget ? nextCacheFiles[relTarget] : undefined;
         const staticEdge = edge.kind === 'import' || edge.kind === 'export';
         const targetTypeOnlyExports =
           staticEdge && Boolean(targetCached?.exportsOnlyTypes) && !edge.typeOnly;
@@ -257,6 +263,7 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           targetTypeNames.size > 0 &&
           !targetCached?.hasTopLevelSideEffects &&
           named.every((n) => targetTypeNames.has(n));
+        const peerIsolation = Boolean(rule.peerIsolation);
         violations.push({
           ruleId: 'LAYER_IMPORT_VIOLATION',
           file: relFile,
@@ -269,7 +276,12 @@ export function runArchitectureScan({ root, config, manifest, rules, files, ts,
           ...(sourcePureTypeModule ? { sourcePureTypeModule: true } : {}),
           ...(namedBindingsTypeOnly ? { namedBindingsTypeOnly: true } : {}),
           ...(edge.kind ? { edgeKind: edge.kind } : {}),
-          message: rule.message ?? `${sourceLayer} must not ${edge.kind} ${targetLayer}.`,
+          ...(peerIsolation ? { peerIsolation: true } : {}),
+          message:
+            rule.message ??
+            (peerIsolation
+              ? `${sourceLayer} must not ${edge.kind} another slice of ${targetLayer} (${relFile} → ${relTarget}). Extract shared code or use events/ports across slices.`
+              : `${sourceLayer} must not ${edge.kind} ${targetLayer}.`),
         });
       }
     }

package/bin/lib/config-warnings.mjs

@@ -10,6 +10,7 @@ import {
   patternSpecificity,
   resolveIntentLayer,
 } from '../ark-shared.mjs';
+import { findDeniedEdgeRule } from '../ark-layer-match.mjs';
 import { normalize } from './scan-files.mjs';
 
 export function intentLayersFromManifest(manifest) {
@@ -36,8 +37,16 @@ export function layerForIntent(intent, layers, manifestIntentLayers) {
   return resolveIntentLayer(intent, source);
 }
 
-export function isBlocked(rules, from, to) {
-  return rules.find((rule) => !rule.allowed && rule.from === from && rule.to === to);
+/**
+ * First denying edge rule for from→to, or undefined.
+ * Path-aware when options.fromPath / options.toPath are set (peerIsolation).
+ * @param {object[]} rules
+ * @param {string} from
+ * @param {string} to
+ * @param {{ fromPath?: string, toPath?: string, layers?: object[] }} [options]
+ */
+export function isBlocked(rules, from, to, options) {
+  return findDeniedEdgeRule(rules, from, to, options);
 }
 
 export function configWarning(ruleId, message, extra = {}) {
@@ -127,7 +136,7 @@ export function collectConfigWarnings(root, config, files, rules, manifest) {
         // Advisory only under --strict-config: monorepo/Next presets ship many optional-looking
         // globs (e.g. src/layouts/**, app/**) that never match when include is ["frontend"].
         // Failing the release gate on dead preset globs caused false CI red while architecture
-        // edges were clean (deer-flow host validation). Real safety is import violations +
+        // edges were clean on multi-package hosts. Real safety is import violations +
         // CONFIG_UNCLASSIFIED_FILES / invalid patterns.
         warnings.push(
           configWarning(

package/bin/lib/core-ratchet.mjs

@@ -0,0 +1,152 @@
+/**
+ * Core-layer optionality ratchet — pure plan + CLI runner.
+ * Keeps ark-check.mjs orchestration-only (dispatch only).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { arkCommand } from '../ark-shared.mjs';
+import { computeCoverage } from './doctor-plan.mjs';
+
+/**
+ * Core layers whose optionality matters once they match files (presets share these names).
+ * Used by doctor adoption gaps and `--ratchet-cores`.
+ */
+export const CORE_LAYER_NAMES = new Set([
+  'DomainModel',
+  'ApplicationOrchestration',
+  'PresentationAdapters',
+  'PersistenceAdapters',
+]);
+
+/**
+ * Plan a ratchet of optional→required for core layers that already match files.
+ * Empty cores stay optional (avoids false ENFORCE theatre). Pure — does not write disk.
+ *
+ * @param {object} config ark.config.json shape
+ * @param {{ name: string, files: number }[]} layerRows coverage layer rows
+ */
+export function planPopulatedCoreRatchet(config, layerRows = []) {
+  const countByName = new Map(
+    (Array.isArray(layerRows) ? layerRows : []).map((row) => [row.name, Number(row.files) || 0])
+  );
+  const ratcheted = [];
+  const alreadyStrict = [];
+  const stillOptionalEmpty = [];
+  const nextLayers = (config?.layers ?? []).map((layer) => {
+    if (!CORE_LAYER_NAMES.has(layer.name)) return layer;
+    const files = countByName.get(layer.name) ?? 0;
+    if (layer.optional !== true) {
+      if (files > 0) alreadyStrict.push({ layer: layer.name, files });
+      return layer;
+    }
+    if (files <= 0) {
+      stillOptionalEmpty.push(layer.name);
+      return layer;
+    }
+    ratcheted.push({ layer: layer.name, files });
+    return { ...layer, optional: false };
+  });
+  return {
+    ratcheted,
+    alreadyStrict,
+    stillOptionalEmpty,
+    config: { ...(config ?? {}), layers: nextLayers },
+    changed: ratcheted.length > 0,
+  };
+}
+
+/**
+ * When the architecture is green (raw violations = 0, not baselined), ratchet populated
+ * core layers from optional→required so doctor can honestly report ENFORCE.
+ * Empty cores stay optional. Always writes when changes apply (like --update-baseline).
+ *
+ * @param {string} root
+ * @param {object} config
+ * @param {string[]} files
+ * @param {object[]} rules
+ * @param {object[]} violations raw scan violations (baseline ignored — must be truly clean)
+ * @param {{ json?: boolean, config?: string }} args
+ * @param {{ displayPathFromRoot: (root: string, abs: string) => string }} deps
+ */
+export function runRatchetCores(root, config, files, rules, violations, args, deps) {
+  const displayPathFromRoot = deps.displayPathFromRoot;
+  const cov = computeCoverage(root, config, files, rules);
+  const activeCount = Array.isArray(violations) ? violations.length : 0;
+  const configPath = path.isAbsolute(args.config)
+    ? args.config
+    : path.join(root, args.config || 'ark.config.json');
+
+  const refuse = (code, message, extra = {}) => {
+    if (args.json) {
+      console.log(JSON.stringify({ ok: false, error: message, ...extra }, null, 2));
+    } else {
+      console.error(message);
+    }
+    process.exitCode = code;
+  };
+
+  if (activeCount > 0) {
+    refuse(
+      2,
+      `Refusing --ratchet-cores: ${activeCount} active architecture violation(s) (raw graph; baseline does not count). Resolve them first (ark-check --plan), then re-run.`,
+      { activeViolations: activeCount, governed: cov.governed }
+    );
+    return;
+  }
+  if (cov.totalFiles === 0 || (cov.governed?.percent ?? 0) < 50) {
+    refuse(
+      2,
+      `Refusing --ratchet-cores: governed coverage is too low (${cov.governed?.percent ?? 0}% of ${cov.totalFiles} files). Classify ungoverned code first.`,
+      { governed: cov.governed }
+    );
+    return;
+  }
+
+  const plan = planPopulatedCoreRatchet(config, cov.layers);
+  if (!plan.changed) {
+    const payload = {
+      ok: true,
+      changed: false,
+      message: 'No optional core layers with files — nothing to ratchet.',
+      alreadyStrict: plan.alreadyStrict,
+      stillOptionalEmpty: plan.stillOptionalEmpty,
+      governed: cov.governed,
+    };
+    if (args.json) console.log(JSON.stringify(payload, null, 2));
+    else {
+      console.log(payload.message);
+      if (plan.stillOptionalEmpty.length > 0) {
+        console.log(`Still optional (empty patterns): ${plan.stillOptionalEmpty.join(', ')}`);
+      }
+    }
+    return;
+  }
+
+  fs.writeFileSync(configPath, `${JSON.stringify(plan.config, null, 2)}\n`);
+  const payload = {
+    ok: true,
+    changed: true,
+    configPath: displayPathFromRoot(root, configPath),
+    ratcheted: plan.ratcheted,
+    stillOptionalEmpty: plan.stillOptionalEmpty,
+    governed: cov.governed,
+    next: arkCommand(root, 'ark-check', '--doctor'),
+  };
+  if (args.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(
+      `Ratcheted ${plan.ratcheted.length} core layer(s) to optional: false (populated only):`
+    );
+    for (const row of plan.ratcheted) {
+      console.log(`  ${row.layer} (${row.files} file(s))`);
+    }
+    if (plan.stillOptionalEmpty.length > 0) {
+      console.log(
+        `Left optional (empty patterns — avoid false ENFORCE): ${plan.stillOptionalEmpty.join(', ')}`
+      );
+    }
+    console.log(`Wrote ${displayPathFromRoot(root, configPath)}`);
+    console.log(`Confirm: ${payload.next}`);
+  }
+}

package/bin/lib/doctor-plan.mjs

@@ -330,6 +330,8 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
                   archetype: recommendation?.archetype,
                   label: recommendation?.label,
                   preset: recommendation?.preset,
+                  galleryStarter: recommendation?.galleryStarter,
+                  policyPack: recommendation?.policyPack,
                   recommendCommand: arkCommand(root, 'ark-check', '--recommend'),
                   initCommand: recommendation?.archetype
                     ? arkCommand(root, 'ark', `init --archetype ${recommendation.archetype} --yes`)
@@ -409,6 +411,24 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
     console.log(color.bold('New here?'));
     if (recommendation) {
       line(warn, `Suggested application shape: ${recommendation.archetype} — ${recommendation.label} (preset ${recommendation.preset})`);
+      if (recommendation.galleryStarter) {
+        line(ok, `Gallery starter: ${recommendation.galleryStarter}`);
+      }
+      if (recommendation.policyPack) {
+        line(ok, `Policy pack: ${arkCommand(root, 'ark-check', `--apply-policy-pack ${recommendation.policyPack}`)}`);
+      }
+      if (recommendation.signals?.nestFramework) {
+        line(
+          ok,
+          'Nest modular monolith → prefer hexagonal (or ddd-bounded-contexts if you have src/contexts/*)'
+        );
+      }
+      if (recommendation.signals?.monorepoTooling?.length) {
+        line(
+          ok,
+          `Monorepo tooling (${recommendation.signals.monorepoTooling.join(', ')}) → preset monorepo (apps/packages/libs)`
+        );
+      }
     } else {
       line(warn, 'Low governed coverage or fresh config — pick an application shape before adding code.');
     }

package/bin/lib/import-resolve.mjs

@@ -0,0 +1,133 @@
+/**
+ * Shared import path → repo-relative + layer resolution for ark-mcp write-gate.
+ * Single primitive so peerIsolation and layer rules share one resolver.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { layerForFile } from '../ark-layer-match.mjs';
+
+/**
+ * Read tsconfig path aliases via the TypeScript config parser (JSONC + extends).
+ * @returns {{ baseUrl: string, aliases: Array<{ from: string, to: string }> }}
+ */
+export function readTsconfigAliases(ts, root) {
+  if (!ts) return { baseUrl: root, aliases: [] };
+  try {
+    const configPath = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath) return { baseUrl: root, aliases: [] };
+    const read = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (read.error) return { baseUrl: root, aliases: [] };
+    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(configPath));
+    const opts = parsed.options || {};
+    const baseUrl = opts.baseUrl || path.dirname(configPath);
+    const aliases = [];
+    for (const [pattern, targets] of Object.entries(opts.paths || {})) {
+      if (!Array.isArray(targets) || targets.length === 0) continue;
+      // Catch-all `*` → empty prefix would match every specifier; skip it.
+      const from = pattern.replace(/\*$/, '');
+      if (!from) continue;
+      aliases.push({ from, to: String(targets[0]).replace(/\*$/, '') });
+    }
+    aliases.sort((a, b) => b.from.length - a.from.length);
+    return { baseUrl, aliases };
+  } catch {
+    return { baseUrl: root, aliases: [] };
+  }
+}
+
+/**
+ * Resolve an import specifier to a repo-relative path.
+ * Relative + tsconfig-aliased only; bare packages → undefined.
+ */
+export function resolveSpecifierToRel(specifier, fromFilePath, root, tsAliases) {
+  let abs;
+  if (specifier.startsWith('./') || specifier.startsWith('../')) {
+    if (!fromFilePath) return undefined;
+    const fromAbs = path.isAbsolute(fromFilePath)
+      ? fromFilePath
+      : path.resolve(root, fromFilePath);
+    abs = path.resolve(path.dirname(fromAbs), specifier);
+  } else {
+    const alias = tsAliases.aliases.find((a) => specifier.startsWith(a.from));
+    if (!alias) return undefined;
+    abs = path.resolve(tsAliases.baseUrl, `${alias.to}${specifier.slice(alias.from.length)}`);
+  }
+  const rel = path.relative(root, abs).split(path.sep).join('/');
+  return rel.startsWith('..') ? undefined : rel;
+}
+
+function filePathToRel(filePath, root) {
+  if (!filePath || typeof filePath !== 'string') return undefined;
+  const abs = path.isAbsolute(filePath) ? filePath : path.resolve(root, filePath);
+  const rel = path.relative(root, abs).split(path.sep).join('/');
+  return rel.startsWith('..') ? undefined : rel;
+}
+
+function classifyProbe(root, rel, layers) {
+  let probe = rel;
+  try {
+    if (fs.statSync(path.join(root, rel)).isDirectory()) probe = `${rel}/index.ts`;
+  } catch {
+    /* not on disk */
+  }
+  return (
+    layerForFile(root, probe, layers) || layerForFile(root, `${rel}/index.ts`, layers)
+  );
+}
+
+/**
+ * One resolver for write-gate: specifier or absolute/repo-relative source file →
+ * `{ relPath, layer }`.
+ */
+export function createImportTargetResolver(ts, root, config) {
+  const layers = config?.layers ?? [];
+  if (layers.length === 0) return undefined;
+  const tsAliases = readTsconfigAliases(ts, root);
+
+  return (specifierOrFilePath, fromFilePath) => {
+    if (!specifierOrFilePath || typeof specifierOrFilePath !== 'string') return undefined;
+
+    // Absolute filesystem path (file being written)
+    if (path.isAbsolute(specifierOrFilePath)) {
+      const relPath = filePathToRel(specifierOrFilePath, root);
+      if (!relPath) return undefined;
+      return { relPath, layer: classifyProbe(root, relPath, layers) };
+    }
+
+    // Relative or path-alias import
+    if (
+      specifierOrFilePath.startsWith('./') ||
+      specifierOrFilePath.startsWith('../') ||
+      specifierOrFilePath.startsWith('@')
+    ) {
+      const rel = resolveSpecifierToRel(
+        specifierOrFilePath,
+        fromFilePath,
+        root,
+        tsAliases
+      );
+      if (!rel) return undefined;
+      return { relPath: rel, layer: classifyProbe(root, rel, layers) };
+    }
+
+    // Try as import alias / bare package first
+    const asImport = resolveSpecifierToRel(
+      specifierOrFilePath,
+      fromFilePath,
+      root,
+      tsAliases
+    );
+    if (asImport) {
+      return { relPath: asImport, layer: classifyProbe(root, asImport, layers) };
+    }
+
+    // Repo-relative source file path (not an import specifier)
+    const asFile = filePathToRel(specifierOrFilePath, root);
+    if (asFile) {
+      return { relPath: asFile, layer: classifyProbe(root, asFile, layers) };
+    }
+
+    return undefined;
+  };
+}
+