pi-soly 1.11.2 → 1.12.0

package/core.ts

@@ -17,6 +17,35 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
+// Shared leaf utilities now live in util.ts; re-exported here so existing
+// `import { ... } from "./core.ts"` call sites keep working unchanged.
+import {
+  atomicWriteFileSync,
+  estimateTokens,
+  extractFilePathsFromPrompt,
+  findMarkdownFiles,
+  formatTok,
+  globToRegExp,
+  matchesGlob,
+  parseRuleFrontmatter,
+  parseStateFrontmatter,
+  readIfExists,
+  splitFrontmatter,
+} from "./util.ts";
+export {
+  atomicWriteFileSync,
+  estimateTokens,
+  extractFilePathsFromPrompt,
+  findMarkdownFiles,
+  formatTok,
+  globToRegExp,
+  matchesGlob,
+  parseRuleFrontmatter,
+  parseStateFrontmatter,
+  readIfExists,
+  splitFrontmatter,
+} from "./util.ts";
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -103,7 +132,12 @@ export interface PhaseInfo {
   planCount: number;
   contextExists: boolean;
   researchExists: boolean;
+  /** Legacy standalone plan files (`NN-MM-PLAN.md`). Superseded by `tasks`. */
   plans: string[];
+  /** Unified model: tasks under `phases/<N>/tasks/<id>/`. Optional during the
+   *  phases→tasks migration (legacy phases have none); the loader always sets
+   *  an array. Becomes required once plans are fully retired. */
+  tasks?: TaskInfo[];
 }
 
 /**
@@ -188,242 +222,6 @@ export const C = {
   reset: "\x1b[0m",
 } as const;
 
-// ============================================================================
-// Frontmatter parsers
-// ============================================================================
-
-// Simple parser for .soly/rules/ frontmatter.
-export function parseRuleFrontmatter(raw: string): {
-  meta: RuleFrontmatter;
-  body: string;
-} {
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-  if (!match) return { meta: {}, body: raw };
-
-  const yamlText = match[1];
-  const body = match[2];
-  const meta: RuleFrontmatter = {};
-
-  for (const line of yamlText.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-
-    const colonIdx = trimmed.indexOf(":");
-    if (colonIdx === -1) continue;
-
-    const key = trimmed.slice(0, colonIdx).trim();
-    let value: string | string[] | boolean = trimmed.slice(colonIdx + 1).trim();
-
-    if (
-      typeof value === "string" &&
-      ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'")))
-    ) {
-      value = value.slice(1, -1);
-    }
-
-    if (
-      typeof value === "string" &&
-      value.startsWith("[") &&
-      value.endsWith("]")
-    ) {
-      const inner = value.slice(1, -1).trim();
-      value =
-        inner.length === 0
-          ? []
-          : inner.split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
-    } else if (value === "true") {
-      value = true;
-    } else if (value === "false") {
-      value = false;
-    }
-
-    (meta as Record<string, unknown>)[key] = value;
-  }
-
-  return { meta, body };
-}
-
-// YAML-ish parser for .soly/STATE.md. Handles 2-level nested objects (for `progress:`).
-export function parseStateFrontmatter(yaml: string): {
-  meta: Record<string, unknown>;
-  progress: ProgressInfo;
-} {
-  const root: Record<string, unknown> = {};
-  const stack: { indent: number; obj: Record<string, unknown> }[] = [
-    { indent: -1, obj: root },
-  ];
-
-  for (const rawLine of yaml.split(/\r?\n/)) {
-    const line = rawLine.replace(/\s+$/, "");
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-
-    const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
-    const content = line.trim();
-
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-      stack.pop();
-    }
-    const parent = stack[stack.length - 1].obj as Record<string, unknown>;
-
-    const colonIdx = content.indexOf(":");
-    if (colonIdx === -1) continue;
-    const key = content.slice(0, colonIdx).trim();
-    let value: unknown = content.slice(colonIdx + 1).trim();
-
-    if (value === "") {
-      const newObj: Record<string, unknown> = {};
-      parent[key] = newObj;
-      stack.push({ indent, obj: newObj });
-      continue;
-    }
-
-    if (typeof value === "string") {
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1);
-      } else if (value === "true") {
-        value = true;
-      } else if (value === "false") {
-        value = false;
-      } else if (/^-?\d+(\.\d+)?$/.test(value)) {
-        const n = Number(value);
-        if (!Number.isNaN(n)) value = n;
-      }
-    }
-    parent[key] = value;
-  }
-
-  const progressObj =
-    (root.progress as Record<string, unknown> | undefined) ?? {};
-  return {
-    meta: root,
-    progress: {
-      totalPhases: Number(progressObj.total_phases ?? 0),
-      completedPhases: Number(progressObj.completed_phases ?? 0),
-      totalPlans: Number(progressObj.total_plans ?? 0),
-      completedPlans: Number(progressObj.completed_plans ?? 0),
-      percent: Number(progressObj.percent ?? 0),
-    },
-  };
-}
-
-export function splitFrontmatter(
-  raw: string,
-): { yaml: string; body: string } | null {
-  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-  return m ? { yaml: m[1], body: m[2] } : null;
-}
-
-// ============================================================================
-// File helpers
-// ============================================================================
-
-export function readIfExists(p: string): string | null {
-  try {
-    return fs.readFileSync(p, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Atomic file write: write to a tmp file in the same directory, then rename
- * to the target. Avoids partial writes when concurrent readers/processes
- * (hot reload, another tool, git status) would otherwise see a half-written
- * file. Best-effort: if rename fails, falls back to a direct write.
- */
-export function atomicWriteFileSync(
-  target: string,
-  content: string,
-  encoding: BufferEncoding = "utf-8",
-): void {
-  const dir = path.dirname(target);
-  const base = path.basename(target);
-  const tmp = path.join(dir, `.${base}.${process.pid}.${Date.now()}.tmp`);
-  try {
-    fs.writeFileSync(tmp, content, encoding);
-    fs.renameSync(tmp, target);
-  } catch {
-    // Fallback: direct write (e.g. cross-device rename on some systems)
-    try {
-      fs.writeFileSync(target, content, encoding);
-    } catch {
-      // best effort — caller handles errors
-    }
-  }
-}
-
-export function findMarkdownFiles(dir: string, basePath = ""): string[] {
-  const results: string[] = [];
-  if (!fs.existsSync(dir)) return results;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name.startsWith(".")) continue;
-    if (entry.name === "node_modules") continue;
-    const relPath = basePath ? `${basePath}/${entry.name}` : entry.name;
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findMarkdownFiles(fullPath, relPath));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      results.push(relPath);
-    }
-  }
-  return results;
-}
-
-export function globToRegExp(glob: string): RegExp {
-  let re = "";
-  for (let i = 0; i < glob.length; i++) {
-    const c = glob[i];
-    if (c === "*") {
-      if (glob[i + 1] === "*") {
-        re += ".*";
-        i++;
-        if (glob[i + 1] === "/") i++;
-      } else {
-        re += "[^/]*";
-      }
-    } else if (c === "?") {
-      re += "[^/]";
-    } else if (".()+|^${}\\".includes(c)) {
-      re += "\\" + c;
-    } else {
-      re += c;
-    }
-  }
-  return new RegExp("^" + re + "$");
-}
-
-export function matchesGlob(pathStr: string, glob: string): boolean {
-  return globToRegExp(glob).test(pathStr);
-}
-
-export function extractFilePathsFromPrompt(prompt: string): string[] {
-  // Only match paths that look like real file references: must contain a slash
-  // or start with ./ and end with a short extension. Avoids catching "1.5",
-  // "i.e.", etc.
-  const matches =
-    prompt.match(
-      /(?:\.{0,2}\/)?(?:[A-Za-z0-9_\-]+\/)+[A-Za-z0-9_\-.]+\.[A-Za-z0-9]{1,5}/g,
-    ) ||
-    prompt.match(/[A-Za-z0-9_\-.]+\.[a-z]{1,5}/g) ||
-    [];
-  return matches;
-}
-
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-export function formatTok(n: number): string {
-  if (n <= 0) return "0";
-  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
-  return String(n);
-}
 
 // ============================================================================
 // Rules
@@ -1294,6 +1092,7 @@ function loadPhaseDir(phaseDir: string): PhaseInfo {
     contextExists: files.some((f) => /-CONTEXT\.md$/.test(f)),
     researchExists: files.some((f) => /-RESEARCH\.md$/.test(f)),
     plans,
+    tasks: listPhaseTasks(phaseDir),
   };
 }
 
@@ -1418,6 +1217,19 @@ function loadTaskDir(taskDir: string): TaskInfo | null {
   };
 }
 
+/** Unified model: load tasks under a phase's `tasks/` subdir. */
+function listPhaseTasks(phaseDir: string): TaskInfo[] {
+  const tasksDir = path.join(phaseDir, "tasks");
+  if (!fs.existsSync(tasksDir)) return [];
+  const tasks: TaskInfo[] = [];
+  for (const e of fs.readdirSync(tasksDir, { withFileTypes: true })) {
+    if (!e.isDirectory()) continue;
+    const t = loadTaskDir(path.join(tasksDir, e.name));
+    if (t) tasks.push(t);
+  }
+  return tasks.sort((a, b) => a.id.localeCompare(b.id));
+}
+
 function listTasks(solyDir: string): TaskInfo[] {
   const tasks: TaskInfo[] = [];
   const featuresDir = path.join(solyDir, "features");

package/deck/deck.ts

@@ -0,0 +1,386 @@
+// =============================================================================
+// deck.ts — full-screen decision-deck TUI component
+// =============================================================================
+//
+// Renders ONE architectural/design decision as a stack of framed "cards" — one
+// option per card — that the user flips through with ←/→ (or 1-N) and picks
+// with Enter. Each card shows a title, prose summary, an optional syntax-
+// highlighted code snippet, and pros/cons. Esc cancels.
+//
+// This is the richer cousin of ask_pro's side-panel preview: instead of a thin
+// column it gives a full card to each option, so the user can compare concrete
+// code shapes and trade-offs before committing. Purely native (no browser, no
+// server) — it composes in pi's TUI like any other custom component and reuses
+// the same hard width-capping discipline as the ask_pro picker.
+// =============================================================================
+
+import {
+	Container,
+	Text,
+	Input,
+	truncateToWidth,
+	type Component,
+	type KeybindingsManager,
+} from "@earendil-works/pi-tui";
+
+/** Minimal theme shape (matches pi's Theme.fg / .bold). */
+export interface DeckTheme {
+	fg: (color: string, text: string) => string;
+	bold: (text: string) => string;
+}
+
+export interface DeckOption {
+	/** Card title (e.g. "Event bus"). */
+	title: string;
+	/** 1-3 sentence prose explanation. */
+	summary?: string;
+	/** Optional code snippet shown on the card. */
+	code?: string;
+	/** Language hint for the code snippet (e.g. "ts"). */
+	lang?: string;
+	/** Upsides, rendered as green "+ …" lines. */
+	pros?: string[];
+	/** Downsides, rendered as "− …" lines. */
+	cons?: string[];
+	/** Mark as the ⭐ recommended option (cursor starts here). */
+	recommended?: boolean;
+}
+
+export interface DeckResult {
+	/** Chosen option index, when the user pressed Enter. */
+	chosen?: number;
+	/** Set when the user cancelled (Esc). */
+	cancelled?: boolean;
+	/** Optional free-text note the user attached to the decision (via `n`). */
+	note?: string;
+}
+
+interface DeckComponentDeps {
+	options: DeckOption[];
+	theme: DeckTheme;
+	keybindings: KeybindingsManager;
+	done: (result: DeckResult) => void;
+	/** Overall decision title. */
+	title?: string;
+	/** The question being decided. */
+	prompt?: string;
+	/** Optional syntax highlighter (pi's highlightCode). */
+	highlight?: (code: string, lang?: string) => string[];
+}
+
+const KEY_ESC = "\x1b";
+const KEY_ENTER = "\n";
+const KEY_ENTER_CR = "\r";
+const KEY_UP = "\x1b[A";
+const KEY_DOWN = "\x1b[B";
+const KEY_RIGHT = "\x1b[C";
+const KEY_LEFT = "\x1b[D";
+const KEY_BACKSPACE = "\x7f";
+const KEY_TAB = "\t";
+
+/** Max card width; cards never grow wider than this even on huge terminals. */
+const MAX_BOX = 96;
+
+export class DeckComponent extends Container {
+	private options: DeckOption[];
+	private theme: DeckTheme;
+	private keybindings: KeybindingsManager;
+	private done: (result: DeckResult) => void;
+	private title: string;
+	private prompt: string;
+	private highlight?: (code: string, lang?: string) => string[];
+
+	private index = 0;
+	private completed = false;
+	private body!: Text;
+	/** Free-text note attached to the decision (via `n`). */
+	private note = "";
+	/** True while the inline note field owns the keyboard. */
+	private noteMode = false;
+	/** The inline Input rendered while noteMode is active. */
+	private noteInput: Input | null = null;
+
+	constructor(deps: DeckComponentDeps) {
+		super();
+		this.options = deps.options;
+		this.theme = deps.theme;
+		this.keybindings = deps.keybindings;
+		this.done = deps.done;
+		this.title = deps.title ?? "decision";
+		this.prompt = deps.prompt ?? "";
+		this.highlight = deps.highlight;
+		this.index = Math.max(
+			0,
+			this.options.findIndex((o) => o.recommended),
+		);
+		this.body = new Text("", 1, 0);
+		this.addChild(this.body);
+	}
+
+	getIndex(): number {
+		return this.index;
+	}
+
+	/** The note currently attached to the decision ("" until one is added). */
+	getNote(): string {
+		return this.note;
+	}
+
+	// --------------------------------------------------------------------------
+	// Input
+	// --------------------------------------------------------------------------
+
+	handleInput(keyData: string): void {
+		if (this.completed) return;
+
+		// --- inline note field owns the keyboard (Enter commits, Esc cancels) ---
+		if (this.noteMode) {
+			this.handleNoteKey(keyData);
+			return;
+		}
+
+		if (keyData === KEY_ESC) {
+			this.finish({ cancelled: true });
+			return;
+		}
+		// `n` — open the inline note field (pre-fills any existing note).
+		if (keyData === "n") {
+			this.openNoteInput();
+			return;
+		}
+		if (
+			this.keybindings.matches(keyData, "tui.select.confirm") ||
+			keyData === KEY_ENTER ||
+			keyData === KEY_ENTER_CR
+		) {
+			this.finish({ chosen: this.index });
+			return;
+		}
+		if (keyData === KEY_LEFT || keyData === KEY_UP || keyData === "h" || keyData === "k") {
+			this.index = Math.max(0, this.index - 1);
+			this.body.invalidate();
+			return;
+		}
+		if (keyData === KEY_RIGHT || keyData === KEY_DOWN || keyData === "l" || keyData === "j") {
+			this.index = Math.min(this.options.length - 1, this.index + 1);
+			this.body.invalidate();
+			return;
+		}
+		const num = parseInt(keyData, 10);
+		if (!isNaN(num) && num >= 1 && num <= this.options.length) {
+			this.index = num - 1;
+			this.body.invalidate();
+		}
+	}
+
+	private finish(result: DeckResult): void {
+		this.completed = true;
+		// Attach the note (if any) to a choice — never to a cancellation.
+		if (!result.cancelled && this.note) result.note = this.note;
+		this.done(result);
+	}
+
+	/** Build a fresh inline Input pre-filled with `value`, cursor at the end so
+	 *  the user can extend or backspace-edit it. */
+	private makeInput(value: string): Input {
+		const input = new Input();
+		for (const ch of value) input.handleInput(ch);
+		return input;
+	}
+
+	/** Open the inline note field, pre-filled with any existing note so it can
+	 *  be edited. While open, all keys route to the field except Enter/Esc. */
+	private openNoteInput(): void {
+		this.noteInput = this.makeInput(this.note);
+		this.noteMode = true;
+		this.body.invalidate();
+	}
+
+	/** Route a keystroke to the active note field, intercepting Enter (commit)
+	 *  and Esc (cancel). Mirrors ask_pro's inline-input behavior. */
+	private handleNoteKey(keyData: string): void {
+		if (!this.noteInput) return;
+		if (keyData === KEY_ESC) {
+			this.closeNote(false);
+			return;
+		}
+		if (
+			this.keybindings.matches(keyData, "tui.select.confirm") ||
+			keyData === KEY_ENTER ||
+			keyData === KEY_ENTER_CR
+		) {
+			this.closeNote(true);
+			return;
+		}
+		// Tab also commits (common "done typing" gesture) so the field doesn't
+		// swallow Tab trying to insert a literal tab.
+		if (keyData === KEY_TAB) {
+			this.closeNote(true);
+			return;
+		}
+		this.noteInput.handleInput(keyData);
+		this.body.invalidate();
+	}
+
+	/** Commit (commit=true) or discard the note field, then return to the
+	 *  card deck. A committed empty value clears any existing note. */
+	private closeNote(commit: boolean): void {
+		const text = this.noteInput?.getValue() ?? "";
+		this.noteInput = null;
+		this.noteMode = false;
+		if (commit) {
+			const trimmed = text.trim();
+			this.note = trimmed === "" ? "" : trimmed;
+		}
+		this.body.invalidate();
+	}
+
+	dispose(): void {
+		this.completed = true;
+		this.noteMode = false;
+		this.noteInput = null;
+	}
+
+	// --------------------------------------------------------------------------
+	// Rendering — every emitted line is hard-capped to `width` visible columns.
+	// --------------------------------------------------------------------------
+
+	render(width: number): string[] {
+		const boxWidth = Math.max(12, Math.min(width, MAX_BOX));
+		const inner = Math.max(4, boxWidth - 4);
+		const opt = this.options[this.index];
+		const out: string[] = [];
+
+		out.push(this.center(this.theme.bold(this.theme.fg("accent", this.title)), boxWidth));
+		for (const l of this.wrap(this.prompt, boxWidth)) {
+			if (l) out.push(this.center(this.theme.fg("dim", l), boxWidth));
+		}
+		out.push("");
+		out.push(this.center(this.renderPager(), boxWidth));
+		out.push("");
+		if (opt) for (const l of this.renderCard(opt, boxWidth, inner)) out.push(l);
+		// Inline note field — shown below the card when noteMode is active.
+		// It owns the keyboard (Enter commits, Esc cancels); see handleNoteKey.
+		if (this.noteMode && this.noteInput) {
+			out.push("");
+			out.push(
+				this.center(
+					this.theme.fg("dim", "Note: (enter ⏎ confirm · esc cancel)"),
+					boxWidth,
+				),
+			);
+			for (const l of this.noteInput.render(inner)) {
+				out.push(truncateToWidth(l, width, "", false));
+			}
+		}
+		out.push("");
+		out.push(this.center(this.theme.fg("dim", this.footerHints()), boxWidth));
+
+		return out.map((l) => truncateToWidth(l, width, "", false));
+	}
+
+	/** A framed card for one option. */
+	private renderCard(opt: DeckOption, boxWidth: number, inner: number): string[] {
+		const bar = "━".repeat(boxWidth - 2);
+		const lines: string[] = [this.theme.fg("accent", `┏${bar}┓`)];
+		const star = opt.recommended ? "⭐ " : "";
+		lines.push(this.box(this.theme.bold(star + opt.title), inner));
+
+		if (opt.summary) {
+			lines.push(this.box("", inner));
+			for (const l of this.wrap(opt.summary, inner)) {
+				lines.push(this.box(this.theme.fg("text", l), inner));
+			}
+		}
+		if (opt.code) {
+			lines.push(this.box("", inner));
+			for (const l of this.highlightLines(opt.code, opt.lang)) {
+				lines.push(this.box(l, inner));
+			}
+		}
+		const pros = opt.pros ?? [];
+		const cons = opt.cons ?? [];
+		if (pros.length || cons.length) {
+			lines.push(this.box("", inner));
+			for (const p of pros) lines.push(this.box(this.theme.fg("success", `+ ${p}`), inner));
+			for (const c of cons) lines.push(this.box(this.theme.fg("warning", `− ${c}`), inner));
+		}
+		lines.push(this.theme.fg("accent", `┗${bar}┛`));
+		return lines;
+	}
+
+	/** Frame one content line inside the card borders, padded to `inner`. */
+	private box(content: string, inner: number): string {
+		const edge = this.theme.fg("accent", "┃");
+		return `${edge} ${truncateToWidth(content, inner, "", true)} ${edge}`;
+	}
+
+	/** `◀  ●○○  2/3  ▶` — the option pager. */
+	private renderPager(): string {
+		const dots = this.options
+			.map((_, i) => this.theme.fg(i === this.index ? "accent" : "dim", i === this.index ? "●" : "○"))
+			.join("");
+		const left = this.theme.fg(this.index > 0 ? "accent" : "dim", "◀");
+		const right = this.theme.fg(this.index < this.options.length - 1 ? "accent" : "dim", "▶");
+		const counter = this.theme.fg("dim", `${this.index + 1}/${this.options.length}`);
+		return `${left}  ${dots}  ${counter}  ${right}`;
+	}
+
+	private footerHints(): string {
+		// While the note field is open it owns the keyboard — show only its
+		// affordances.
+		if (this.noteMode) return "⏎ confirm · esc cancel";
+		const noteHint = this.note ? "n ✓note" : "n note";
+		return `←/→ flip · 1-N jump · ${noteHint} · ⏎ choose · esc cancel`;
+	}
+
+	/** Highlight (or dim-fallback) a code snippet into per-line styled strings. */
+	private highlightLines(code: string, lang?: string): string[] {
+		const src = code.replace(/\r\n/g, "\n").replace(/\s+$/, "");
+		return this.highlight
+			? this.highlight(src, lang)
+			: src.split("\n").map((l) => this.theme.fg("dim", l));
+	}
+
+	/** Center a (possibly styled) string within `width` visible columns. */
+	private center(s: string, width: number): string {
+		const pad = Math.max(0, Math.floor((width - this.visible(s)) / 2));
+		return " ".repeat(pad) + s;
+	}
+
+	/** Visible width of a styled string (strips ANSI/OSC for the count). */
+	private visible(s: string): number {
+		// eslint-disable-next-line no-control-regex
+		return s.replace(/\x1b\[[0-9;]*m/g, "").replace(/\x1b\]8;[^\x07]*\x07/g, "").length;
+	}
+
+	/** Greedy word-wrap (split on existing newlines first). `.length` is a safe
+	 *  upper bound — callers hard-cap the final row, so a miscount can't overflow. */
+	private wrap(text: string, maxWidth: number): string[] {
+		if (!text) return [];
+		const out: string[] = [];
+		for (const raw of text.replace(/\r\n/g, "\n").split("\n")) {
+			if (raw.trim() === "") {
+				out.push("");
+				continue;
+			}
+			let cur = "";
+			for (const w of raw.split(" ")) {
+				const word = w.length > maxWidth ? truncateToWidth(w, maxWidth, "") : w;
+				if (cur.length === 0) cur = word;
+				else if (cur.length + 1 + word.length <= maxWidth) cur += ` ${word}`;
+				else {
+					out.push(cur);
+					cur = word;
+				}
+			}
+			out.push(cur);
+		}
+		return out;
+	}
+}
+
+/** Type guard for the public component. */
+export function isDeckComponent(c: Component): c is DeckComponent {
+	return c instanceof DeckComponent;
+}