fapony 0.3.4 → 0.3.6

package/src/adapters/mcp/tools/index.ts

@@ -3,7 +3,7 @@
 // Every schema here is paid as input tokens in *every* session of *every*
 // client that connects, whether or not the tool is called. Adding one is
 // buying attention with a standing charge; earning it back means the tool
-// saves more than it costs (see CLAUDE.md "จ่าย token อย่างฉลาด"). Keep
+// saves more than it costs (see CLAUDE.md "Spend tokens smart"). Keep
 // descriptions imperative — say what to send, not why it matters.
 
 export { toolMemAdd, toolMemClose, toolMemFind } from "./mem.js";
@@ -59,6 +59,11 @@ export const TOOLS = [
           description:
             "Max rows returned (default 20) — total still counts all matches",
         },
+        open: {
+          type: "boolean",
+          description:
+            "true = unresolved work only: drops close/claim/release/synced rows and work rows already closed. Omit = every row. With kind:[bug] answers 'what bugs remain?'",
+        },
       },
       required: ["worktree"],
     },

package/src/adapters/mcp/tools/mem.ts

@@ -6,15 +6,14 @@
 // file is unfindable when you touch that file (fill rate 26% CLI-flag vs 88%
 // MCP-required — schema wins over prose every time, see CLAUDE.md rule 9).
 
-import { openRows } from "../../../mem/selectors.js";
 import {
-  initStore,
-  KINDS,
-  nextId,
-  put,
-  rows,
-  type WorkKind,
-} from "../../../mem/store.js";
+  type EngineAddResult,
+  type EngineCloseResult,
+  engineAdd,
+  engineClose,
+  engineFind,
+} from "../../../mem/engine.js";
+import { initStore, KINDS, type WorkKind } from "../../../mem/store.js";
 import { type MemRow, readMemLog, resolveMemDir } from "../../../memory.js";
 import { errorResult, jsonResult, type ToolResult } from "../types.js";
 
@@ -33,37 +32,24 @@ export function memFind(args: {
   kind?: string[];
   since?: string;
   limit?: number;
+  open?: boolean;
 }): MemFindResult {
-  const read = readMemLog(args.worktree, args.since);
-
-  let rows = read.rows;
-  if (args.kind && args.kind.length > 0) {
-    const kinds = new Set(args.kind);
-    rows = rows.filter((r) => kinds.has(r.kind));
-  }
-  if (args.text) {
-    const needle = args.text.toLowerCase();
-    rows = rows.filter((r) => r.text.toLowerCase().includes(needle));
-  }
-  if (args.files && args.files.length > 0) {
-    // Rows written by `mem add --files` carry files[] — match that first.
-    // Older rows (and any row whose author skipped --files) have none, so the
-    // text/spec/ref substring stays as the fallback: low recall by nature,
-    // a limit of the data rather than of the query (spec §5.4).
-    const paths = args.files.map((f) => f.toLowerCase());
-    rows = rows.filter((r) => {
-      const stored = (r.files ?? []).map((f) => f.toLowerCase());
-      if (stored.some((f) => paths.some((p) => f === p || f.endsWith(`/${p}`))))
-        return true;
-      const hay = `${r.text}\n${r.spec ?? ""}\n${r.ref ?? ""}`.toLowerCase();
-      return paths.some((p) => hay.includes(p));
-    });
-  }
-
-  const total = rows.length;
-  const limit = Math.max(0, args.limit ?? 20);
+  // Query logic lives in the shared engine (src/mem/engine.ts) — this wrapper
+  // owns only the read (readMemLog sees live + rotated archives via its loose
+  // log*.jsonl regex) and the result shape. No kind default here by contract:
+  // omitting kind returns every kind (locked by test). CLI cmdFind calls the
+  // same engine with its own bookkeeping exclude.
+  const read = readMemLog(args.worktree);
+  const { rows: matched, total } = engineFind(read.rows, {
+    text: args.text,
+    files: args.files,
+    kind: args.kind,
+    sinceIso: args.since,
+    limit: args.limit,
+    open: args.open,
+  });
   return {
-    rows: rows.slice(0, limit),
+    rows: matched,
     total,
     filesFound: read.filesFound,
     skipped: read.skipped,
@@ -100,24 +86,25 @@ export function toolMemFind(args: Record<string, unknown>): ToolResult {
     : undefined;
   const text = typeof args.text === "string" ? args.text : undefined;
   const since = typeof args.since === "string" ? args.since : undefined;
+  if (since !== undefined && Number.isNaN(Date.parse(since))) {
+    return errorResult(
+      `since must be an ISO date (e.g. 2026-09-19T00:00:00.000Z), got: "${since}" — CLI accepts <N>d/YYYY-MM-DD, MCP takes ISO only`,
+    );
+  }
   const limit = typeof args.limit === "number" ? args.limit : undefined;
+  const open = typeof args.open === "boolean" ? args.open : undefined;
 
-  return jsonResult(memFind({ worktree, files, text, kind, since, limit }));
+  return jsonResult(
+    memFind({ worktree, files, text, kind, since, limit, open }),
+  );
 }
 
 // --- mem_add ---
+//
+// Domain rules live in the shared engine (src/mem/engine.ts) — this wrapper
+// owns only store init for its worktree. CLI cmdAdd calls the same engine.
 
-export interface MemAddResult {
-  id: string;
-  kind: string;
-  text: string;
-  files: string[];
-  spec?: string;
-  ts: string;
-}
-
-const CAP_NEXT = 15;
-const CAP_HOLD = 10;
+export type MemAddResult = EngineAddResult;
 
 export function memAdd(args: {
   worktree: string;
@@ -126,62 +113,13 @@ export function memAdd(args: {
   files: string[];
   spec?: string;
 }): MemAddResult {
-  if (!KINDS.includes(args.kind as WorkKind)) {
-    throw new Error(
-      `kind must be one of ${KINDS.join("|")} — got "${args.kind}"`,
-    );
-  }
-  if (args.files.length === 0) {
-    throw new Error("files must contain at least one path");
-  }
-  if (!args.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-  // CLI cmdAdd rejects hold without a spec (write.ts) — keep the two writers
-  // in lockstep: without a spec a hold can never be resolved by rotate.
-  if (args.kind === "hold" && !args.spec) {
-    throw new Error("hold requires a spec — pass spec: <path/to/SPEC.md>");
-  }
-
   initStore(args.worktree);
-  const all = rows();
-
-  // Cap check — matches CLI cmdAdd behaviour
-  if (args.kind === "next" && !process.env.MEM_FORCE) {
-    const openNext = openRows(all).filter((r) => r.kind === "next").length;
-    if (openNext >= CAP_NEXT) {
-      throw new Error(
-        `open next ${openNext}/${CAP_NEXT} is full — close an old one first`,
-      );
-    }
-  }
-  if (args.kind === "hold" && !process.env.MEM_FORCE) {
-    const openHold = openRows(all).filter((r) => r.kind === "hold").length;
-    if (openHold >= CAP_HOLD) {
-      throw new Error(
-        `open hold ${openHold}/${CAP_HOLD} is full — close/release an old one first`,
-      );
-    }
-  }
-
-  const id = nextId(all);
-  const ts = new Date().toISOString();
-  put({
-    id,
-    kind: args.kind as WorkKind,
-    text: args.text,
-    spec: args.spec,
-    files: args.files,
-  });
-
-  return {
-    id,
+  return engineAdd({
     kind: args.kind,
     text: args.text,
     files: args.files,
     spec: args.spec,
-    ts,
-  };
+  });
 }
 
 export function toolMemAdd(args: Record<string, unknown>): ToolResult {
@@ -246,34 +184,15 @@ export function toolMemAdd(args: Record<string, unknown>): ToolResult {
 // (commands/write.ts cmdClose): the id must exist; the tombstone voids the
 // claim by itself.
 
-export interface MemCloseResult {
-  ref: string;
-  text: string;
-  ts: string;
-}
+export type MemCloseResult = EngineCloseResult;
 
 export function memClose(args: {
   worktree: string;
   id: string;
   text: string;
 }): MemCloseResult {
-  if (!args.id.trim()) {
-    throw new Error("id is required");
-  }
-  if (!args.text.trim()) {
-    throw new Error("text is required and must not be empty");
-  }
-
   initStore(args.worktree);
-  const all = rows();
-  if (!all.some((r) => "id" in r && r.id === args.id)) {
-    throw new Error(`no id "${args.id}" in the log`);
-  }
-
-  const ts = new Date().toISOString();
-  put({ kind: "close", ref: args.id, text: args.text });
-
-  return { ref: args.id, text: args.text, ts };
+  return engineClose({ id: args.id, text: args.text });
 }
 
 export function toolMemClose(args: Record<string, unknown>): ToolResult {

package/src/commands.ts

@@ -0,0 +1,180 @@
+// src/commands.ts — the single source of truth for top-level command names.
+//
+// Dispatch stays an if-chain in src/adapters/cli.ts (rule 1: this is a data
+// table, not a framework — no registry class, no plugin hooks). This table
+// owns name + group + one-line summary; `fapony --help` renders from it and
+// test/docs.test.ts fails when a name here is missing from the docs, so the
+// four copies (if-chain, usage, CLAUDE.md, README) cannot drift silently.
+// Zero imports — cli.ts loads this on every startup (≤ ~100ms budget).
+
+export type CommandGroup =
+  | "core"
+  | "usage"
+  | "lookup"
+  | "hooks"
+  | "setup"
+  | "frozen";
+
+export interface CommandInfo {
+  name: string;
+  group: CommandGroup;
+  summary: string;
+}
+
+const GROUP_ORDER: CommandGroup[] = [
+  "core",
+  "usage",
+  "lookup",
+  "hooks",
+  "setup",
+  "frozen",
+];
+
+export const COMMANDS: CommandInfo[] = [
+  {
+    name: "mem",
+    group: "core",
+    summary: "project pain memory: decisions, bugs, notes",
+  },
+  {
+    name: "debt",
+    group: "core",
+    summary: "which files haven't migrated to a declared convention",
+  },
+  {
+    name: "lint-baseline",
+    group: "core",
+    summary: 'separate "already red" from "I made it red"',
+  },
+  { name: "init-mem", group: "core", summary: "delete legacy .memory/ dirs" },
+  {
+    name: "digest",
+    group: "core",
+    summary: "single-page summary from what's on disk",
+  },
+  {
+    name: "usage-scan",
+    group: "usage",
+    summary: "scan session logs into the cache",
+  },
+  { name: "usage-web", group: "usage", summary: "usage dashboard from cache" },
+  {
+    name: "price-scan",
+    group: "usage",
+    summary: "refresh the model price table",
+  },
+  {
+    name: "analyze",
+    group: "lookup",
+    summary: "live repo graph: hubs, orphans, cycles",
+  },
+  {
+    name: "review-seed",
+    group: "lookup",
+    summary: "read-only scope facts for a review",
+  },
+  {
+    name: "plan-seed",
+    group: "lookup",
+    summary: "write PLAN (+SPEC) with capped sections",
+  },
+  {
+    name: "mcp",
+    group: "hooks",
+    summary: "MCP server (stdio JSON-RPC, 3 tools)",
+  },
+  {
+    name: "hook-stop",
+    group: "hooks",
+    summary: "Stop hook: block turns with commits but no mem row",
+  },
+  {
+    name: "hook-read-hint",
+    group: "hooks",
+    summary: "read/re-read annotations",
+  },
+  {
+    name: "hook-edit-hint",
+    group: "hooks",
+    summary: "importer count before editing shape",
+  },
+  {
+    name: "hook-mv-guard",
+    group: "hooks",
+    summary: "deny raw git mv of plan files into done/",
+  },
+  {
+    name: "hook-session-start",
+    group: "hooks",
+    summary: "SessionStart: kickoff into context",
+  },
+  { name: "init", group: "setup", summary: "scaffold .fapony/ in a worktree" },
+  {
+    name: "install",
+    group: "setup",
+    summary: "wire MCP + skills into clients",
+  },
+  { name: "setup", group: "setup", summary: "interactive wizard" },
+  { name: "update", group: "setup", summary: "self-update via git pull" },
+  { name: "telemetry", group: "setup", summary: "opt-in telemetry show/send" },
+  {
+    name: "stats",
+    group: "frozen",
+    summary: "frozen-ledger KPIs (reads history only)",
+  },
+  { name: "report", group: "frozen", summary: "verification report for a run" },
+  { name: "report-web", group: "frozen", summary: "static HTML report page" },
+];
+
+// Grouped names only — the shape PLAN-seed-and-surface §7 picked. Starts with
+// a `usage: fapony` line: scripts/smoke-publish.sh greps for it on a no-arg run.
+export const renderUsage = (): string => {
+  const lines = [
+    "fapony — project pain memory for agent-written code",
+    "usage: fapony <command> [args]",
+    "",
+  ];
+  for (const g of GROUP_ORDER) {
+    const names = COMMANDS.filter((c) => c.group === g).map((c) => c.name);
+    lines.push(`  ${g.padEnd(8)}${names.join("  ")}`);
+  }
+  lines.push(
+    "",
+    "  fapony mem <sub> --help     per-subcommand details (only mem has --help)",
+  );
+  return lines.join("\n");
+};
+
+// Classic two-row Levenshtein — the did-you-mean behind unknown-command errors.
+export const levenshtein = (a: string, b: string): number => {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(
+        prev[j] + 1,
+        cur[j - 1] + 1,
+        prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+    }
+    prev = cur;
+  }
+  return prev[b.length];
+};
+
+// Up to 3 suggestions within distance ≤ 2, against top-level names and mem
+// subs (so `fapony plan-check` offers `fapony mem plan-check`). Sorted by
+// distance, then alphabetically — deterministic for tests.
+export const suggestCommand = (cmd: string, memSubs: string[]): string[] => {
+  const scored: Array<{ text: string; d: number }> = [];
+  for (const c of COMMANDS) {
+    const d = levenshtein(cmd, c.name);
+    if (d <= 2) scored.push({ text: `fapony ${c.name}`, d });
+  }
+  for (const s of memSubs) {
+    const d = levenshtein(cmd, s);
+    if (d <= 2) scored.push({ text: `fapony mem ${s}`, d });
+  }
+  scored.sort((x, y) => x.d - y.d || (x.text < y.text ? -1 : 1));
+  return scored.slice(0, 3).map((s) => s.text);
+};

package/src/core/debt-format.ts

@@ -77,7 +77,7 @@ export function formatDebt(report: DebtReport, showAll = false): string {
     for (let i = 0; i < cap; i++) {
       const [zone, zoneFiles] = zoneEntries[i];
       const pad = " ".repeat(Math.max(0, 42 - zone.length));
-      lines.push(`\n  ${zone}${pad}${zoneFiles.length} ไฟล์`);
+      lines.push(`\n  ${zone}${pad}${zoneFiles.length} files`);
       lines.push(`    ${zoneFiles.map((f) => f.split("/").pop()).join(" · ")}`);
       totalCapped += zoneFiles.length;
     }
@@ -85,7 +85,7 @@ export function formatDebt(report: DebtReport, showAll = false): string {
       const remaining = e.files.length - totalCapped;
       const remainingZones = zoneEntries.length - cap;
       lines.push(
-        `\n  … อีก ${remainingZones} โซน (${remaining} ไฟล์) — fapony debt --id ${e.conv.id} --all`,
+        `\n  … ${remainingZones} more zones (${remaining} files) — fapony debt --id ${e.conv.id} --all`,
       );
     }
   }

package/src/core/since.ts

@@ -0,0 +1,26 @@
+// src/core/since.ts — parse `--since` (Nd | YYYY-MM-DD) into an ISO timestamp.
+//
+// Pure date math, no imports. Two callers share it: digest/collect.ts and
+// mem find (CLI --since + MCP sinceIso passthrough). It lives in core because
+// both are features and core never imports back up (PLAN-unify-mem-engine
+// chunk 2 — digest/collect.ts used to own this, but importing it from mem
+// would drag db/store + hook.js into the mem load path).
+
+export function parseSince(
+  raw: string | undefined,
+  now?: number,
+): { iso: string; label: string } {
+  const def = "7d";
+  const s = raw ?? def;
+  const dMatch = /^(\d+)d$/.exec(s);
+  if (dMatch) {
+    const days = Number(dMatch[1]);
+    const dt = new Date((now ?? Date.now()) - days * 86400000);
+    return { iso: dt.toISOString(), label: `${days}d` };
+  }
+  const dateMatch = /^\d{4}-\d{2}-\d{2}$/.exec(s);
+  if (dateMatch) {
+    return { iso: `${s}T00:00:00.000Z`, label: s };
+  }
+  throw new Error(`invalid --since format: "${s}" — use <N>d or YYYY-MM-DD`);
+}

package/src/debt/cli.ts

@@ -6,7 +6,7 @@ import { existsSync, realpathSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { CONVENTIONS_FILE } from "../core/config.js";
 import { formatDebt } from "./format.js";
-import { loadConventions } from "./load.js";
+import { resolveDebtScope } from "./load.js";
 import { findPromotions, formatPromotions } from "./promotion.js";
 import { debtForFile, debtScan } from "./scan.js";
 import { ZONE_CAP } from "./types.js";
@@ -119,12 +119,26 @@ export function cmdDebt(args: string[]): void {
     }
   }
 
-  const worktree = worktreeOf(path);
-  const loaded = loadConventions(worktree);
+  // Scan scope: the git root (convention `where` values are repo-relative)
+  // paired with the nearest conventions file — scanning from the app dir
+  // dropped repo-relative conventions and hid files outside the app
+  // (bug mucvfiv5). Evidence (mem/ledger) keeps the old neighborhood scope.
+  // Physical path (symlinks resolved) so --files resolution below compares
+  // like with like against scope.scanRoot (/var → /private/var on macOS).
+  let base = resolve(path ?? ".");
+  try {
+    base = realpathSync(base);
+  } catch {
+    // nonexistent — the not-found notes below handle it
+  }
+  const scope = resolveDebtScope(base);
+  const worktree = scope.scanRoot;
+  const loaded = scope.loaded;
+  const evidenceDir = worktreeOf(path);
 
   if (filesMode) {
     const out = filesMode.map((f) => {
-      const abs = isAbsolute(f) ? f : resolve(worktree, f);
+      const abs = isAbsolute(f) ? f : resolve(base, f);
       if (!existsSync(abs) || !statSync(abs).isFile()) {
         return { file: f, debt: [], note: "not found" as const };
       }
@@ -178,7 +192,7 @@ export function cmdDebt(args: string[]): void {
   if (json) {
     console.log(
       JSON.stringify(
-        { ...report, promotions: findPromotions(worktree, report) },
+        { ...report, promotions: findPromotions(evidenceDir, report) },
         null,
         2,
       ),
@@ -187,7 +201,7 @@ export function cmdDebt(args: string[]): void {
   }
   console.log(formatDebt(report, showAll));
   for (const w of loaded.warnings) console.log(`⚠ ${w}`);
-  for (const l of formatPromotions(findPromotions(worktree, report))) {
+  for (const l of formatPromotions(findPromotions(evidenceDir, report))) {
     console.log(l);
   }
 }

package/src/debt/load.ts

@@ -4,8 +4,14 @@
 // (<repo>/.fapony/conventions.json — via the same resolver as the mem log).
 // Missing file = empty + no error.
 
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
 import {
   CONVENTIONS_FILE,
   CONVENTIONS_FILENAME,
@@ -28,6 +34,134 @@ export function resolveConventionsPath(worktree: string): string | null {
   return existsSync(root) ? root : null;
 }
 
+export interface DebtScope {
+  /**
+   * The dir `where` clauses and debt rel-paths are measured against — the git
+   * root inside a repo (convention `where` values are repo-relative), the
+   * resolved start dir outside one.
+   */
+  scanRoot: string;
+  /** Conventions in scope: nearest file walking up, else the lone file under the root. */
+  loaded: LoadedConventions;
+}
+
+// Dirs that never hold a conventions.json and are expensive to walk — same
+// prune set as the mem-log ambiguity scan (src/core/mem-log.ts).
+const SCOPE_SKIP = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  "vendor",
+  "out",
+  "target",
+  ".next",
+  ".turbo",
+  ".cache",
+]);
+
+/** Every `.fapony/conventions.json` under root — bounded walk, pruned dirs skipped. */
+function findConventionsUnder(root: string): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, depth: number): void => {
+    if (depth > 6) return;
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name === FAPONY_DIR) {
+        const f = join(dir, FAPONY_DIR, CONVENTIONS_FILENAME);
+        if (existsSync(f)) found.push(f);
+        continue;
+      }
+      if (e.name.startsWith(".") || SCOPE_SKIP.has(e.name)) continue;
+      walk(join(dir, e.name), depth + 1);
+    }
+  };
+  walk(root, 0);
+  return found;
+}
+
+/**
+ * The single debt-scope resolver — hint (`readContextData`), the precision
+ * instrument (`computeHintImpact`), and `fapony debt` all pair the same
+ * scan root with the same conventions (bugs mucvfaxk + mucvfiv5).
+ *
+ * Each caller previously resolved differently: the hint and the instrument
+ * anchored `loadConventions` at the git root (silent whenever conventions are
+ * app-scoped), while the CLI scanned from the app dir (so repo-relative
+ * `where` values never matched and files outside the app were invisible).
+ * The scan root here is always the git root — `where` is repo-relative —
+ * and the conventions are the nearest file walking up from `fromDir`
+ * (the app case); when the walk misses — a file outside any app dir, or the
+ * repo root itself — the lone `conventions.json` under the root wins.
+ * Two or more files under the root stay ambiguous (null, don't guess).
+ */
+export function resolveDebtScope(fromDir: string): DebtScope {
+  let start = resolve(fromDir);
+  try {
+    if (!statSync(start).isDirectory()) start = dirname(start);
+  } catch {
+    // nonexistent path — keep the lexical form, resolution below still applies
+  }
+  try {
+    // Physical path so the walk, the boundary check, and scanRoot compare
+    // like with like (/var → /private/var on macOS).
+    start = realpathSync(start);
+  } catch {
+    // vanished mid-call — keep the lexical form
+  }
+  // `git rev-parse` returns a physical path (/var → /private/var on macOS),
+  // so the boundary check compares realpaths, same as worktreeOf in cli.ts.
+  const physical = (d: string): string => {
+    try {
+      return realpathSync(d);
+    } catch {
+      return d;
+    }
+  };
+  let gitRoot: string | null = null;
+  try {
+    const p = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+      cwd: start,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (p.exitCode === 0) gitRoot = p.stdout.toString().trim() || null;
+  } catch {
+    // not a repo — start is all we have
+  }
+  const scanRoot = gitRoot ? physical(gitRoot) : start;
+  const boundary = gitRoot ? physical(gitRoot) : null;
+
+  // Nearest conventions.json walking up (the app case) — bounded by the root.
+  let dir = start;
+  while (true) {
+    if (existsSync(join(dir, CONVENTIONS_FILE))) {
+      return { scanRoot, loaded: loadConventions(dir) };
+    }
+    if (boundary && physical(dir) === boundary) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Sibling-app case: the file sits outside any app dir (e.g. packages/*),
+  // but the repo holds exactly one conventions file — use it.
+  if (gitRoot) {
+    const found = findConventionsUnder(scanRoot);
+    if (found.length === 1) {
+      return { scanRoot, loaded: loadConventions(dirname(dirname(found[0]))) };
+    }
+  }
+  return { scanRoot, loaded: loadConventions(scanRoot) };
+}
+
 function asString(v: unknown): string | undefined {
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }