ziprin-context-optimizer 8.0.0

package/src/pruner.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const path = require('path');
+const { tokens } = require('./estimate');
+const { getProfile } = require('./profiles');
+
+/**
+ * Strong context-pruning algorithm for Cursor chat.
+ * Scores candidate files by task relevance and fits them under a token budget.
+ * Prefer tools (Serena/grep) over dumping; never invent contracts.
+ */
+
+const TOKEN_BOMBS = [
+  /\.cursor\/agents\//,
+  /\.cursor\/skills\//,
+  /\.cursor\/_tmp/,
+  /tooling\/project-index\.json$/,
+  /project-must-follow-catalog\.json$/,
+  /\/reports\/.*\.json$/,
+  /node_modules\//,
+  /\.git\//,
+  /\.vsix$/,
+];
+
+const HIGH_VALUE = [
+  /\/src\//,
+  /packages\/(ui|shared)\//,
+  /AGENTS\.md$/,
+  /ziprin-supervisor\.mdc$/,
+  /\.policy\.json$/,
+  /auth\/contracts\//,
+];
+
+function isTokenBomb(rel) {
+  const r = rel.replace(/\\/g, '/');
+  return TOKEN_BOMBS.some((re) => re.test(r));
+}
+
+function baseScore(rel, query = '') {
+  const r = rel.replace(/\\/g, '/');
+  let s = 0;
+  if (isTokenBomb(r)) return -1000;
+  for (const re of HIGH_VALUE) if (re.test(r)) s += 30;
+  if (/\.(ts|tsx|js|jsx)$/.test(r)) s += 10;
+  if (/\.(mdc|md)$/.test(r) && !r.includes('.cursor/agents') && !r.includes('.cursor/skills')) s += 5;
+  if (query) {
+    const q = query.toLowerCase();
+    const parts = q.split(/[^a-z0-9_/-]+/).filter(Boolean);
+    for (const p of parts) {
+      if (p.length < 2) continue;
+      if (r.toLowerCase().includes(p)) s += 25;
+    }
+  }
+  // Prefer shallow public APIs
+  if (/\/index\.(ts|tsx)$/.test(r)) s += 8;
+  if (/\/(test|spec|__tests__)\//.test(r)) s -= 15;
+  return s;
+}
+
+/**
+ * @param {Array<{path:string, bytes:number}>} candidates
+ * @param {{query?:string, profileId?:string, maxTokens?:number}} opts
+ */
+function pruneCandidates(candidates, opts = {}) {
+  const profile = getProfile(opts.profileId || 'standard');
+  const budget = opts.maxTokens ?? profile.maxOnDemandTokens;
+  const cpt = profile.charsPerToken || 4;
+  const query = opts.query || '';
+
+  const scored = candidates
+    .map((c) => {
+      const rel = c.path.replace(/\\/g, '/');
+      const score = baseScore(rel, query);
+      const tok = tokens(c.bytes || 0, cpt);
+      return { path: rel, bytes: c.bytes || 0, tokens: tok, score };
+    })
+    .filter((c) => c.score > -500)
+    .sort((a, b) => b.score - a.score || a.tokens - b.tokens);
+
+  const selected = [];
+  let used = 0;
+  const rejected = [];
+  for (const c of scored) {
+    if (c.tokens <= 0) continue;
+    if (used + c.tokens > budget) {
+      rejected.push({ ...c, reason: 'budget' });
+      continue;
+    }
+    selected.push(c);
+    used += c.tokens;
+  }
+
+  return {
+    profile: profile.id,
+    budget,
+    usedTokens: used,
+    selected,
+    rejected,
+    toolsFirst: profile.preferToolsFirst
+      ? ['serena.find_symbol', 'grep', 'read_file', 'ziprinSuperGuard.scanCurrentFile']
+      : [],
+    qualityNote:
+      'Pruner keeps high-score product paths under budget; token bombs stay out. Tools-first avoids dumping folders.',
+  };
+}
+
+/**
+ * Build a chat context plan from a natural-language task.
+ */
+function planChatContext(task, candidates, opts = {}) {
+  const profile = getProfile(opts.profileId || 'standard');
+  const pruned = pruneCandidates(candidates, { ...opts, query: task, profileId: profile.id });
+  const steps = [];
+  if (profile.preferSerena) {
+    steps.push({ action: 'tool', tool: 'serena', why: 'Symbol-level lookup before file dump' });
+  }
+  if (profile.preferToolsFirst) {
+    steps.push({ action: 'tool', tool: 'grep', why: 'Locate exact references without loading whole trees' });
+  }
+  steps.push({ action: 'read', files: pruned.selected.slice(0, 12).map((s) => s.path), why: 'Budgeted relevant sources' });
+  if (!profile.allowAgentsInChat) {
+    steps.push({ action: 'skip', what: '.cursor/agents/**', why: 'Agents live in Super Guard pack; not chat context' });
+  }
+  if (!profile.allowSkillsInChat) {
+    steps.push({ action: 'skip', what: '.cursor/skills/**', why: 'Skills invoked on demand via routing, not always-loaded' });
+  }
+  return { task, profile: profile.id, steps, pruned };
+}
+
+module.exports = { isTokenBomb, baseScore, pruneCandidates, planChatContext, TOKEN_BOMBS, HIGH_VALUE };

package/src/quality-guard.js

@@ -0,0 +1,122 @@
+'use strict';
+
+/**
+ * Context Quality Guard — prevent aggressive pruning mistakes.
+ * Restores explicitly mentioned symbols, paths, and domain-relevant files.
+ */
+
+function qualityCheck(opts) {
+  const {
+    taskTokens = [],
+    selected = [],
+    restored = [],
+    scores = [],
+    budget,
+    usedTokens,
+    symbols = [],
+    pathHints = [],
+    domain = null,
+  } = opts;
+
+  const issues = [];
+  const actions = [];
+
+  // Explicit path mentions should be present
+  for (const t of taskTokens) {
+    if (!/\.(ts|tsx|js|jsx|mdc|md)$/.test(t) && !t.includes('/')) continue;
+    const hit = selected.some((p) => p.includes(t) || t.includes(p));
+    if (!hit) {
+      const candidate = scores.find((s) => s.path.includes(t));
+      if (candidate) {
+        issues.push(`Mentioned path missing: ${t}`);
+        actions.push({ condition: 'Removing file may reduce answer accuracy', action: 'keep file', path: candidate.path });
+      }
+    }
+  }
+
+  // Symbol names mentioned in prompt must be in selected files
+  for (const sym of symbols) {
+    const symLower = sym.toLowerCase();
+    const symKebab = sym.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    const hit = selected.some(
+      (p) => p.toLowerCase().includes(symLower) || p.toLowerCase().includes(symKebab),
+    );
+    if (!hit) {
+      const candidate = scores.find(
+        (s) => s.path.toLowerCase().includes(symLower) || s.path.toLowerCase().includes(symKebab),
+      );
+      if (candidate) {
+        issues.push(`Mentioned symbol missing: ${sym}`);
+        actions.push({ condition: 'Mentioned symbol file excluded', action: 'keep file', path: candidate.path });
+      }
+    }
+  }
+
+  // Path hints from prompt must be in selected files
+  for (const hint of pathHints) {
+    const hit = selected.some((p) => p.toLowerCase().includes(hint));
+    if (!hit) {
+      const candidate = scores.find((s) => s.path.toLowerCase().includes(hint));
+      if (candidate) {
+        issues.push(`Mentioned feature path missing: ${hint}`);
+        actions.push({ condition: 'Feature path excluded', action: 'keep file', path: candidate.path });
+      }
+    }
+  }
+
+  // Domain mismatch: if domain is set, at least one selected file should be in priority paths
+  if (domain && domain.priorityPaths && domain.priorityPaths.length > 0) {
+    const domainHit = selected.some((p) =>
+      domain.priorityPaths.some((dp) => p.toLowerCase().includes(dp.toLowerCase())),
+    );
+    if (!domainHit) {
+      issues.push(`Task domain mismatch: ${domain.label} files missing`);
+      const candidates = scores
+        .filter((s) => domain.priorityPaths.some((dp) => s.path.toLowerCase().includes(dp.toLowerCase())))
+        .slice(0, 5);
+      for (const c of candidates) {
+        actions.push({ condition: 'Domain-relevant file excluded', action: 'keep file', path: c.path });
+      }
+    }
+  }
+
+  if (restored.length) {
+    for (const p of restored) {
+      actions.push({ condition: 'Required dependency missing', action: 'restore dependency', path: p });
+    }
+  }
+
+  if (selected.length === 0) {
+    issues.push('No files selected — restoring top scoring sources');
+    const top = scores.filter((s) => s.final_score > 0).slice(0, 5).map((s) => s.path);
+    actions.push({ condition: 'Empty context', action: 'keep file', paths: top });
+  }
+
+  const tokenPressure = budget ? usedTokens / budget : 0;
+  const ok =
+    selected.length > 0 &&
+    issues.filter((i) => i.startsWith('Mentioned') || i.startsWith('Task domain')).length === 0;
+
+  return {
+    ok,
+    issues,
+    actions,
+    tokenPressure,
+    qualityNote: ok
+      ? 'Quality guard: selected set can plausibly answer the task (heuristic).'
+      : 'Quality guard: weak context — restored dependencies / mentioned paths.',
+  };
+}
+
+function applyQualityActions(selected, scores, quality) {
+  const set = new Set(selected);
+  for (const a of quality.actions || []) {
+    if (a.path) set.add(a.path);
+    if (a.paths) for (const p of a.paths) set.add(p);
+  }
+  // keep order by score
+  const order = new Map(scores.map((s, i) => [s.path, i]));
+  return [...set].sort((a, b) => (order.get(a) ?? 999) - (order.get(b) ?? 999));
+}
+
+module.exports = { qualityCheck, applyQualityActions };

package/src/query-rewrite.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Rewrite vague FA/EN prompts using last-session domain + synonyms.
+ */
+
+const VAGUE_RE =
+  /^(درستش\s*کن|فیکس\s*کن|باگ\s*داره|خراب\s*شده|اینو\s*درست\s*کن|درستش\s*کن\s*لطفا|fix\s*it|it'?s\s*broken|broken|help|؟+)$/i;
+
+function rewriteQuery(prompt, memory = {}) {
+  const p = String(prompt || '').trim();
+  const vague = VAGUE_RE.test(p);
+  if (!vague) return { rewritten: p, vague: false, extra: [] };
+
+  const extra = [];
+  const lastDomain = memory.lastDomain || memory.domainHits && Object.keys(memory.domainHits).sort(
+    (a, b) => (memory.domainHits[b] || 0) - (memory.domainHits[a] || 0),
+  )[0];
+  if (lastDomain === 'marketplace' || /marketplace/.test(lastDomain || '')) extra.push('marketplace', 'cart', 'checkout');
+  if (lastDomain === 'bss_vendor' || /vendor/.test(lastDomain || '')) extra.push('vendor', 'add-product', 'product-status');
+  if (lastDomain === 'bss_dashboard') extra.push('dashboard', 'bss', 'ticket');
+
+  const lastFiles = Object.keys(memory.pathBoost || {})
+    .sort((a, b) => (memory.pathBoost[b] || 0) - (memory.pathBoost[a] || 0))
+    .slice(0, 3);
+  extra.push(...lastFiles.map((f) => f.split('/').slice(-2).join(' ')));
+
+  const rewritten = [p, ...extra.filter(Boolean)].join(' ').trim();
+  return { rewritten, vague: true, extra };
+}
+
+module.exports = { rewriteQuery, VAGUE_RE };

package/src/relevance-scorer.js

@@ -0,0 +1,197 @@
+'use strict';
+
+const path = require('path');
+const { isTokenBomb } = require('./pruner');
+
+/**
+ * Relevance Scoring Engine — confidence scoring, never blind delete.
+ * Explicit prompt signals (symbols, paths, domains) get highest priority.
+ */
+
+function pathKeywords(rel) {
+  return String(rel || '')
+    .toLowerCase()
+    .replace(/\\/g, '/')
+    .split(/[\/._-]+/)
+    .filter((p) => p.length > 1);
+}
+
+function scoreFile(rel, opts = {}) {
+  const r = String(rel || '').replace(/\\/g, '/');
+  const rLower = r.toLowerCase();
+  const taskTokens = opts.taskTokens || [];
+  const mentioned = opts.mentionedPaths || [];
+  const deps = opts.dependencyBoost || new Set();
+  const memoryBoost = opts.memoryBoost || {};
+  const recentSet = opts.recentPaths || new Set();
+  const bytes = opts.bytes || 0;
+  const category = opts.category || 'mixed';
+  const domain = opts.domain || null;
+  const symbols = opts.symbols || [];
+  const pathHints = opts.pathHints || [];
+
+  const breakdown = {
+    task_match: 0,
+    explicit_mention: 0,
+    symbol_match: 0,
+    path_hint_match: 0,
+    domain_match: 0,
+    import_relation: 0,
+    recent_change: 0,
+    folder_importance: 0,
+    architecture_importance: 0,
+    historical_usefulness: 0,
+    size_penalty: 0,
+    generated_penalty: 0,
+    category_fit: 0,
+  };
+
+  if (isTokenBomb(r)) {
+    return { path: r, final_score: -1000, breakdown: { ...breakdown, generated_penalty: -1000 }, keep: false };
+  }
+
+  const fileParts = pathKeywords(r);
+
+  // --- Explicit signal boosts (highest priority) ---
+
+  // Symbol match: PascalCase symbol names in prompt vs file path/name
+  for (const sym of symbols) {
+    const symLower = sym.toLowerCase();
+    const symKebab = sym.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    if (rLower.includes(symLower) || rLower.includes(symKebab)) {
+      breakdown.symbol_match = 100;
+      break;
+    }
+  }
+
+  // Path hint match: "product-status", "vendor/product-status" etc.
+  const wantsAddProduct = pathHints.includes('add-product');
+  const wantsProductStatus = pathHints.includes('product-status');
+  for (const hint of pathHints) {
+    if (rLower.includes(hint)) {
+      breakdown.path_hint_match = Math.max(breakdown.path_hint_match, 90);
+    }
+  }
+  if (wantsAddProduct && !wantsProductStatus && rLower.includes('product-status')) {
+    breakdown.path_hint_match = Math.min(breakdown.path_hint_match, -30);
+  }
+  if (wantsAddProduct && rLower.includes('add-product')) {
+    breakdown.path_hint_match = Math.max(breakdown.path_hint_match, 95);
+    if (/\.api\.(ts|tsx)$/.test(rLower) || /\.mapper\.(ts|tsx)$/.test(rLower)) {
+      breakdown.path_hint_match = Math.max(breakdown.path_hint_match, 98);
+    }
+    if (/\.types\.(ts|tsx)$/.test(rLower)) {
+      breakdown.category_fit -= 15;
+    }
+  }
+
+  // Domain match: BSS vs marketplace priority paths
+  if (domain && domain.priorityPaths) {
+    for (const dp of domain.priorityPaths) {
+      if (rLower.startsWith(dp.toLowerCase()) || rLower.includes(dp.toLowerCase())) {
+        breakdown.domain_match = 70;
+        break;
+      }
+    }
+  }
+
+  // --- Standard factors ---
+
+  for (const t of taskTokens) {
+    if (t.length < 3) continue;
+    if (rLower.includes(t) || fileParts.includes(t)) breakdown.task_match += 8;
+  }
+  breakdown.task_match = Math.min(40, breakdown.task_match);
+
+  for (const m of mentioned) {
+    if (r.includes(String(m).replace(/\\/g, '/'))) breakdown.explicit_mention = 50;
+  }
+
+  const depHit =
+    (deps instanceof Set && (deps.has(r) || [...deps].some((d) => r === d || r.startsWith(String(d) + '/')))) ||
+    (deps && typeof deps === 'object' && !Array.isArray(deps) && (deps[r] || Object.keys(deps).some((d) => r === d || r.startsWith(d + '/'))));
+  if (depHit) breakdown.import_relation = 30;
+  if (recentSet.has(r)) breakdown.recent_change = 20;
+
+  if (/\/src\//.test(r)) breakdown.folder_importance += 10;
+  if (/packages\/(ui|shared)\//.test(r)) breakdown.folder_importance += 8;
+  if (/ziprin-supervisor\.mdc$|\.policy\.json$/.test(r)) {
+    breakdown.architecture_importance += 12;
+  }
+  if (/AGENTS\.md$/.test(r)) breakdown.generated_penalty -= 30;
+  if (/\/index\.(ts|tsx)$/.test(r) && /packages\//.test(r)) breakdown.size_penalty -= 15;
+
+  if (category === 'frontend') {
+    if (/\.(tsx|css|module\.css)$/.test(r) || /packages\/ui\//.test(r)) breakdown.category_fit += 15;
+    if (/\/server\//.test(r) || /migration|database/.test(r)) breakdown.category_fit -= 20;
+  }
+  if (category === 'backend') {
+    if (/\/server\/|service|schema|repository|api/.test(r) || /packages\/shared\//.test(r)) {
+      breakdown.category_fit += 15;
+    }
+    if (/\.tsx$|\.css$/.test(r)) breakdown.category_fit -= 15;
+  }
+  if (category === 'architecture') {
+    if (/\.mdc$|governance|architecture|supervisor/.test(r)) breakdown.category_fit += 20;
+  }
+
+  const mem = memoryBoost[r] || memoryBoost[path.dirname(r)] || 0;
+  breakdown.historical_usefulness = Math.min(25, mem);
+
+  if (bytes > 80_000) breakdown.size_penalty -= 20;
+  else if (bytes > 30_000) breakdown.size_penalty -= 10;
+
+  if (/report|generated|seed|fixture|mock-data|catalog-data/i.test(r)) {
+    breakdown.generated_penalty -= 40;
+  }
+  const action = opts.action || '';
+  const promptText = String(opts.prompt || '').toLowerCase();
+  if (/\/(test|spec|__tests__)\//.test(r) || /\.(test|spec)\./.test(r)) {
+    if (/test|spec|unit|vitest|jest/.test(promptText)) breakdown.category_fit += 8;
+    else breakdown.generated_penalty -= 25;
+  }
+  if (/\/public\//.test(r)) breakdown.generated_penalty -= 50;
+
+  const final_score = Object.values(breakdown).reduce((a, b) => a + b, 0);
+  const confidence = Math.min(100, Math.max(0, Math.round(final_score)));
+  const whySelected = explainScore(breakdown, r);
+  return {
+    path: r,
+    final_score,
+    breakdown,
+    keep: final_score >= 15,
+    confidence,
+    whySelected,
+  };
+}
+
+function explainScore(breakdown, rel) {
+  const reasons = [];
+  if (breakdown.symbol_match) reasons.push('symbol match');
+  if (breakdown.path_hint_match) reasons.push('feature path match');
+  if (breakdown.domain_match) reasons.push('domain match');
+  if (breakdown.explicit_mention) reasons.push('explicit path mention');
+  if (breakdown.import_relation) reasons.push('import dependency');
+  if (breakdown.task_match) reasons.push('task keyword');
+  if (breakdown.historical_usefulness) reasons.push('historical success');
+  if (breakdown.folder_importance) reasons.push('source folder');
+  if (breakdown.generated_penalty <= -40) reasons.push('generated/noise penalty');
+  if (breakdown.size_penalty) reasons.push('large file penalty');
+  if (!reasons.length) reasons.push('low signal');
+  return `${rel}: ${reasons.join(', ')} (score factors)`;
+}
+
+function explainRemoval(breakdown, final_score, reason) {
+  if (reason) return reason;
+  if (final_score < 15) return 'low relevance score';
+  if (breakdown.generated_penalty <= -40) return 'generated or fixture file';
+  return 'budget or pruning';
+}
+
+function scoreCandidates(files, opts) {
+  return files
+    .map((f) => scoreFile(f.path, { ...opts, bytes: f.bytes }))
+    .sort((a, b) => b.final_score - a.final_score);
+}
+
+module.exports = { scoreFile, scoreCandidates, pathKeywords, explainScore, explainRemoval };

package/src/repo-map.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { extractImports } = require('./dependency-graph');
+const { isSourceFile } = require('./collector');
+
+const REPO_MAP_REL = '.cursor/context-gateway-repo-map.json';
+const EXPORT_RE = /^export\s+(?:async\s+)?(?:function|class|const|type|interface|enum)\s+([A-Za-z0-9_]+)/gm;
+
+const DOMAIN_OWNERSHIP = [
+  { id: 'bss_vendor', prefix: 'apps/dashboard/bss/src/portals/vendor' },
+  { id: 'bss_dashboard', prefix: 'apps/dashboard/bss/src' },
+  { id: 'marketplace', prefix: 'apps/marketplace/src' },
+  { id: 'shared', prefix: 'packages/shared/src' },
+  { id: 'ui', prefix: 'packages/ui/src' },
+];
+
+function repoMapPath(root) {
+  return path.join(root, REPO_MAP_REL);
+}
+
+function domainForPath(rel) {
+  const r = String(rel || '').replace(/\\/g, '/');
+  for (const d of DOMAIN_OWNERSHIP) {
+    if (r.startsWith(d.prefix)) return d.id;
+  }
+  return null;
+}
+
+function extractSymbolsFromFile(text) {
+  const syms = new Set();
+  EXPORT_RE.lastIndex = 0;
+  let m;
+  while ((m = EXPORT_RE.exec(text))) syms.add(m[1]);
+  return [...syms];
+}
+
+function buildRepoMap(root, seedPaths = [], maxFiles = 120) {
+  const entries = {};
+  const edges = [];
+  const queue = [...new Set(seedPaths)].slice(0, maxFiles);
+  const seen = new Set();
+
+  while (queue.length && seen.size < maxFiles) {
+    const rel = queue.shift();
+    if (!rel || seen.has(rel)) continue;
+    seen.add(rel);
+    if (!isSourceFile(rel)) continue;
+
+    const abs = path.join(root, rel);
+    let text = '';
+    let mtime = 0;
+    try {
+      const st = fs.statSync(abs);
+      mtime = st.mtimeMs;
+      text = fs.readFileSync(abs, 'utf8').slice(0, 80_000);
+    } catch {
+      continue;
+    }
+
+    const symbols = extractSymbolsFromFile(text);
+    const imports = extractImports(text);
+    entries[rel] = {
+      domain: domainForPath(rel),
+      symbols,
+      mtime,
+      importCount: imports.length,
+    };
+
+    for (const spec of imports.slice(0, 20)) {
+      edges.push({ from: rel, spec });
+    }
+  }
+
+  return {
+    version: 1,
+    builtAt: new Date().toISOString(),
+    fileCount: Object.keys(entries).length,
+    entries,
+    edges: edges.slice(0, 200),
+  };
+}
+
+function loadRepoMap(root) {
+  const file = repoMapPath(root);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveRepoMap(root, map) {
+  fs.mkdirSync(path.dirname(repoMapPath(root)), { recursive: true });
+  fs.writeFileSync(repoMapPath(root), JSON.stringify(map, null, 2), 'utf8');
+}
+
+function getOrBuildRepoMap(root, seedPaths) {
+  const cached = loadRepoMap(root);
+  const ageMs = cached?.builtAt ? Date.now() - Date.parse(cached.builtAt) : Infinity;
+  if (cached && ageMs < 3600_000 && cached.fileCount > 0) return cached;
+  const map = buildRepoMap(root, seedPaths);
+  saveRepoMap(root, map);
+  return map;
+}
+
+function symbolPathsFromMap(map, symbol) {
+  if (!map?.entries || !symbol) return [];
+  const symLower = symbol.toLowerCase();
+  const kebab = symbol.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+  return Object.entries(map.entries)
+    .filter(([, e]) => e.symbols?.some((s) => s.toLowerCase() === symLower || s === symbol))
+    .map(([p]) => p)
+    .concat(
+      Object.keys(map.entries).filter((p) => {
+        const pl = p.toLowerCase();
+        return pl.includes(symLower) || pl.includes(kebab);
+      }),
+    )
+    .filter((p, i, a) => a.indexOf(p) === i)
+    .slice(0, 10);
+}
+
+module.exports = {
+  REPO_MAP_REL,
+  buildRepoMap,
+  loadRepoMap,
+  saveRepoMap,
+  getOrBuildRepoMap,
+  domainForPath,
+  symbolPathsFromMap,
+};