@thecat69/cache-ctrl 1.0.0 → 1.2.0

package/src/types/commands.ts

@@ -2,10 +2,12 @@ import type { AgentType, ExternalCacheFile, LocalCacheFile } from "./cache.js";
 
 // ── list ──────────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `list` command. */
 export interface ListArgs {
   agent?: AgentType | "all";
 }
 
+/** One entry returned by the `list` command. */
 export interface ListEntry {
   file: string;
   agent: AgentType;
@@ -16,10 +18,16 @@ export interface ListEntry {
   is_stale: boolean;
 }
 
+/** Success payload shape returned by the `list` command. */
 export type ListResult = { ok: true; value: ListEntry[] };
 
 // ── inspect ───────────────────────────────────────────────────────────────────
 
+/**
+ * Arguments accepted by the `inspect` command.
+ * @remarks `agent` controls result shape: `external` returns an external entry, while
+ * `local` returns local cache content with `tracked_files` removed and optional facts filters.
+ */
 export interface InspectArgs {
   agent: AgentType;
   subject: string;
@@ -39,9 +47,10 @@ export interface InspectArgs {
   searchFacts?: string[];
 }
 
+/** Success payload shape returned by the `inspect` command. */
 export type InspectResult = {
   ok: true;
-  value: (ExternalCacheFile | LocalCacheFile) & {
+  value: (ExternalCacheFile | Omit<LocalCacheFile, "tracked_files">) & {
     file: string;
     agent: AgentType;
   };
@@ -49,11 +58,13 @@ export type InspectResult = {
 
 // ── flush ─────────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `flush` command. */
 export interface FlushArgs {
   agent: AgentType | "all";
   confirm: boolean;
 }
 
+/** Success payload shape returned by the `flush` command. */
 export type FlushResult = {
   ok: true;
   value: {
@@ -64,11 +75,13 @@ export type FlushResult = {
 
 // ── invalidate ────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `invalidate` command. */
 export interface InvalidateArgs {
   agent: AgentType;
   subject?: string;
 }
 
+/** Success payload shape returned by the `invalidate` command. */
 export type InvalidateResult = {
   ok: true;
   value: {
@@ -78,11 +91,13 @@ export type InvalidateResult = {
 
 // ── touch ─────────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `touch` command. */
 export interface TouchArgs {
   agent: AgentType;
   subject?: string;
 }
 
+/** Success payload shape returned by the `touch` command. */
 export type TouchResult = {
   ok: true;
   value: {
@@ -93,12 +108,14 @@ export type TouchResult = {
 
 // ── prune ─────────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `prune` command. */
 export interface PruneArgs {
   agent?: AgentType | "all";
   maxAge?: string;
   delete?: boolean;
 }
 
+/** Success payload shape returned by the `prune` command. */
 export type PruneResult = {
   ok: true;
   value: {
@@ -108,29 +125,9 @@ export type PruneResult = {
   };
 };
 
-// ── check-freshness ───────────────────────────────────────────────────────────
-
-export interface CheckFreshnessArgs {
-  subject: string;
-  url?: string;
-}
-
-export type CheckFreshnessResult = {
-  ok: true;
-  value: {
-    subject: string;
-    sources: Array<{
-      url: string;
-      status: "fresh" | "stale" | "error";
-      http_status?: number;
-      error?: string;
-    }>;
-    overall: "fresh" | "stale" | "error";
-  };
-};
-
 // ── check-files ───────────────────────────────────────────────────────────────
 
+/** Success payload shape returned by the `check-files` command. */
 export type CheckFilesResult = {
   ok: true;
   value: {
@@ -148,10 +145,12 @@ export type CheckFilesResult = {
 
 // ── search ────────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `search` command. */
 export interface SearchArgs {
   keywords: string[];
 }
 
+/** Success payload shape returned by the `search` command. */
 export type SearchResult = {
   ok: true;
   value: Array<{
@@ -166,12 +165,18 @@ export type SearchResult = {
 
 // ── write ─────────────────────────────────────────────────────────────────────
 
+/**
+ * Shared write-command input contract.
+ * @remarks `agent` selects write mode: `external` requires `subject`; `local` ignores
+ * `subject` and writes `context.json` using local schema semantics.
+ */
 export interface WriteArgs {
   agent: AgentType;
   subject?: string; // required for external, unused for local
   content: Record<string, unknown>;
 }
 
+/** Success payload shape returned by write commands. */
 export type WriteResult = {
   ok: true;
   value: {
@@ -179,14 +184,110 @@ export type WriteResult = {
   };
 };
 
+// ── graph ─────────────────────────────────────────────────────────────────────
+
+/** Arguments accepted by the `graph` command. */
+export interface GraphArgs {
+  maxTokens?: number;
+  seed?: string[];
+}
+
+// ── watch ─────────────────────────────────────────────────────────────────────
+
+/** Arguments accepted by the `watch` command. */
+export interface WatchArgs {
+  verbose?: boolean;
+}
+
+/** Success payload shape returned by the `graph` command. */
+export interface GraphResult {
+  value: {
+    ranked_files: Array<{
+      path: string;
+      rank: number;
+      deps: string[];
+      defs: string[];
+      ref_count: number;
+    }>;
+    total_files: number;
+    computed_at: string;
+    token_estimate: number;
+  };
+}
+
+// ── map ───────────────────────────────────────────────────────────────────────
+
+/** Output depth levels supported by the `map` command. */
+export type MapDepth = "overview" | "modules" | "full";
+
+/** Arguments accepted by the `map` command. */
+export interface MapArgs {
+  depth?: MapDepth;
+  folder?: string;
+}
+
+/** Success payload shape returned by the `map` command. */
+export interface MapResult {
+  value: {
+    depth: MapDepth;
+    global_facts: string[];
+    files: Array<{
+      path: string;
+      summary?: string;
+      role?: string;
+      importance?: number;
+      facts?: string[];
+    }>;
+    modules?: Record<string, string[]>;
+    total_files: number;
+    folder_filter?: string;
+  };
+}
+
 // ── install ───────────────────────────────────────────────────────────────────
 
+/** Arguments accepted by the `install` command. */
 export interface InstallArgs {
   configDir?: string;
 }
 
+/** Success payload shape returned by the `install` command. */
 export interface InstallResult {
   toolPath: string;
   skillPaths: string[];
   configDir: string;
 }
+
+// ── version ───────────────────────────────────────────────────────────────────
+
+/** Arguments accepted by the `version` command. */
+export type VersionArgs = Record<string, never>;
+
+/** Success payload shape returned by the `version` command. */
+export type VersionResult = { value: { version: string } };
+
+// ── update / uninstall ────────────────────────────────────────────────────────
+
+/** Arguments accepted by the `update` command. */
+export interface UpdateArgs {
+  configDir?: string;
+}
+
+/** Success payload shape returned by the `update` command. */
+export interface UpdateResult {
+  packageUpdated: boolean;
+  installedPaths: string[];
+  warnings: string[];
+}
+
+/** Arguments accepted by the `uninstall` command. */
+export interface UninstallArgs {
+  configDir?: string;
+}
+
+/** Success payload shape returned by the `uninstall` command. */
+export interface UninstallResult {
+  removed: string[];
+  packageUninstalled: boolean;
+  warnings: string[];
+}

package/src/types/result.ts

@@ -1,36 +1,53 @@
+/**
+ * Enumerates all typed failure categories returned by cache-ctrl commands and services.
+ */
 export enum ErrorCode {
-  // File system errors
+  /** Returned when an expected cache file is absent on disk. */
   FILE_NOT_FOUND = "FILE_NOT_FOUND",
+  /** Returned when a file cannot be read due to I/O or permission errors. */
   FILE_READ_ERROR = "FILE_READ_ERROR",
+  /** Returned when a write, rename, delete, or other mutating file operation fails. */
   FILE_WRITE_ERROR = "FILE_WRITE_ERROR",
+  /** Returned when file content is present but not valid JSON. */
   PARSE_ERROR = "PARSE_ERROR",
 
-  // Lock errors
+  /** Returned when advisory lock acquisition exceeds the configured wait timeout. */
   LOCK_TIMEOUT = "LOCK_TIMEOUT",
+  /** Returned when lock file operations fail for reasons other than contention timeout. */
   LOCK_ERROR = "LOCK_ERROR",
 
-  // Validation errors
+  /** Returned when CLI arguments are missing, malformed, or violate command constraints. */
   INVALID_ARGS = "INVALID_ARGS",
+  /** Returned when a destructive operation is requested without explicit confirmation. */
   CONFIRMATION_REQUIRED = "CONFIRMATION_REQUIRED",
+  /** Returned when schema or structural validation fails for user-supplied content. */
   VALIDATION_ERROR = "VALIDATION_ERROR",
 
-  // Search/match errors
+  /** Returned when keyword matching yields zero candidates. */
   NO_MATCH = "NO_MATCH",
+  /** Returned when keyword matching yields multiple top-scoring candidates. */
   AMBIGUOUS_MATCH = "AMBIGUOUS_MATCH",
 
-  // HTTP errors
-  HTTP_REQUEST_FAILED = "HTTP_REQUEST_FAILED",
-  URL_NOT_FOUND = "URL_NOT_FOUND",
-
-  // Internal
+  /** Returned for unexpected internal exceptions converted at command boundaries. */
   UNKNOWN = "UNKNOWN",
 }
 
+/**
+ * Canonical failure payload used by the error branch of {@link Result}.
+ */
 export interface CacheError {
   code: ErrorCode;
   error: string;
 }
 
+/**
+ * Discriminated union used for recoverable operation outcomes.
+ *
+ * @typeParam T - Success payload type carried when `ok` is `true`.
+ * @typeParam E - Failure payload shape; defaults to {@link CacheError}.
+ * @remarks Consumers must branch on `ok`. The success branch contains `value`; the
+ * failure branch contains `error` and a typed `code`.
+ */
 export type Result<T, E extends CacheError = CacheError> =
   | { ok: true; value: T }
   | { ok: false; error: string; code: E["code"] };

package/src/utils/errors.ts

@@ -0,0 +1,14 @@
+import { ErrorCode } from "../types/result.js";
+
+/**
+ * Converts an unknown thrown value into the canonical UNKNOWN result shape.
+ *
+ * @param err - Untrusted thrown value caught at a command boundary.
+ * @returns `Result<never>`-compatible failure payload with {@link ErrorCode.UNKNOWN}.
+ * @remarks This is the canonical catch-all converter used by command handlers to avoid
+ * leaking thrown exceptions across the Result-based API boundary.
+ */
+export function toUnknownResult(err: unknown): { ok: false; error: string; code: ErrorCode.UNKNOWN } {
+  const error = err instanceof Error ? err.message : String(err);
+  return { ok: false, error, code: ErrorCode.UNKNOWN };
+}

package/src/utils/traversal.ts

@@ -0,0 +1,42 @@
+/**
+ * Runtime guard for Zod `superRefine` contexts.
+ *
+ * @param value - Candidate refinement context value.
+ * @returns Type predicate that confirms `value` exposes Zod-compatible `addIssue`.
+ * @remarks This guard avoids unsafe assumptions when helper functions are reused outside
+ * Zod's refinement pipeline.
+ */
+export function isRefinementContext(
+  value: unknown,
+): value is { addIssue: (issue: { code: "custom"; message: string; path: string[] }) => void } {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  return typeof (value as Record<string, unknown>)["addIssue"] === "function";
+}
+
+/**
+ * Rejects object keys that can be interpreted as traversal-capable file paths.
+ *
+ * @param record - Object whose keys are validated (for example `facts` map keys).
+ * @param ctx - Zod refinement context used to report validation issues.
+ * @remarks Security control: blocks keys containing `..`, leading `/`, `\\`, or `\x00`
+ * to prevent path-traversal and null-byte injection when keys are later consumed as
+ * filesystem-relative paths.
+ */
+export function rejectTraversalKeys(record: Record<string, unknown>, ctx: unknown): void {
+  if (!isRefinementContext(ctx)) {
+    return;
+  }
+
+  for (const key of Object.keys(record)) {
+    if (key.includes("..") || key.startsWith("/") || key.includes("\\") || key.includes("\x00")) {
+      ctx.addIssue({
+        code: "custom",
+        message: `facts key contains a path traversal or invalid character: "${key}"`,
+        path: [key],
+      });
+    }
+  }
+}

package/src/commands/checkFreshness.ts

@@ -1,123 +0,0 @@
-import { findRepoRoot, readCache, writeCache } from "../cache/cacheManager.js";
-import { isExternalStale, mergeHeaderMetadata, resolveTopExternalMatch } from "../cache/externalCache.js";
-import { checkFreshness } from "../http/freshnessChecker.js";
-import type { ExternalCacheFile } from "../types/cache.js";
-import { ExternalCacheFileSchema } from "../types/cache.js";
-import { ErrorCode, type Result } from "../types/result.js";
-import type { CheckFreshnessArgs, CheckFreshnessResult } from "../types/commands.js";
-import type { HeaderMeta } from "../cache/externalCache.js";
-import { getFileStem } from "../utils/fileStem.js";
-
-export async function checkFreshnessCommand(args: CheckFreshnessArgs): Promise<Result<CheckFreshnessResult["value"]>> {
-  try {
-    const repoRoot = await findRepoRoot(process.cwd());
-
-    // Find the best-matching external cache entry file path
-    const matchResult = await resolveTopExternalMatch(repoRoot, args.subject);
-    if (!matchResult.ok) return matchResult;
-
-    const filePath = matchResult.value;
-
-    // Load the matched entry's data
-    const readResult = await readCache(filePath);
-    if (!readResult.ok) return readResult;
-
-    const parseResult = ExternalCacheFileSchema.safeParse(readResult.value);
-    if (!parseResult.success) {
-      return { ok: false, error: `Malformed external cache file: ${filePath}`, code: ErrorCode.PARSE_ERROR };
-    }
-
-    const cacheEntry = parseResult.data;
-    const stem = getFileStem(filePath);
-    const subject = cacheEntry.subject ?? stem;
-
-    // Determine which URLs to check
-    const sources = cacheEntry.sources ?? [];
-    let urlsToCheck = sources;
-
-    if (args.url) {
-      const found = sources.find((s) => s.url === args.url);
-      if (!found) {
-        return {
-          ok: false,
-          error: `URL not found in sources for subject '${subject}'`,
-          code: ErrorCode.URL_NOT_FOUND,
-        };
-      }
-      urlsToCheck = [found];
-    } else {
-      urlsToCheck = sources;
-    }
-
-    // Check freshness for each URL
-    const sourceResults: Array<{
-      url: string;
-      status: "fresh" | "stale" | "error";
-      http_status?: number;
-      error?: string;
-    }> = [];
-
-    const headerUpdates: Record<string, HeaderMeta> = {};
-
-    for (const source of urlsToCheck) {
-      const stored = cacheEntry.header_metadata?.[source.url];
-      const result = await checkFreshness({
-        url: source.url,
-        ...(stored?.etag !== undefined ? { etag: stored.etag } : {}),
-        ...(stored?.last_modified !== undefined ? { last_modified: stored.last_modified } : {}),
-      });
-
-      sourceResults.push({
-        url: result.url,
-        status: result.status,
-        ...(result.http_status !== undefined ? { http_status: result.http_status } : {}),
-        ...(result.error !== undefined ? { error: result.error } : {}),
-      });
-
-      if (result.status !== "error") {
-        headerUpdates[source.url] = {
-          ...(result.etag !== undefined ? { etag: result.etag } : {}),
-          ...(result.last_modified !== undefined ? { last_modified: result.last_modified } : {}),
-          checked_at: new Date().toISOString(),
-          status: result.status,
-        };
-      }
-    }
-
-    // Only write back if at least one URL succeeded
-    const hasSuccessfulChecks = Object.keys(headerUpdates).length > 0;
-    if (hasSuccessfulChecks) {
-      const updated = mergeHeaderMetadata(cacheEntry, headerUpdates);
-      const writeResult = await writeCache(filePath, { header_metadata: updated.header_metadata });
-      if (!writeResult.ok) return writeResult;
-    }
-
-    // Determine overall status: entryIsOld always wins (stale by age), then anyStale, then allError
-    const allError = sourceResults.every((r) => r.status === "error");
-    const anyStale = sourceResults.some((r) => r.status === "stale");
-    const entryIsOld = isExternalStale(cacheEntry);
-
-    let overall: "fresh" | "stale" | "error";
-    if (entryIsOld) {
-      overall = "stale";
-    } else if (anyStale) {
-      overall = "stale";
-    } else if (allError && sourceResults.length > 0) {
-      overall = "error";
-    } else {
-      overall = "fresh";
-    }
-
-    return {
-      ok: true,
-      value: {
-        subject,
-        sources: sourceResults,
-        overall,
-      },
-    };
-  } catch (err) {
-    const error = err as Error;
-    return { ok: false, error: error.message, code: ErrorCode.UNKNOWN };
-  }
-}

package/src/commands/write.ts

@@ -1,170 +0,0 @@
-import { join } from "node:path";
-import { ExternalCacheFileSchema, LocalCacheFileSchema } from "../types/cache.js";
-import { ErrorCode, type Result } from "../types/result.js";
-import type { WriteArgs, WriteResult } from "../types/commands.js";
-import { writeCache, findRepoRoot, resolveCacheDir, readCache } from "../cache/cacheManager.js";
-import { validateSubject, formatZodError } from "../utils/validate.js";
-import { resolveTrackedFileStats, filterExistingFiles } from "../files/changeDetector.js";
-import type { TrackedFile } from "../types/cache.js";
-import { TrackedFileSchema } from "../types/cache.js";
-
-function evictFactsForDeletedPaths(
-  facts: Record<string, string[]>,
-  survivingFiles: TrackedFile[],
-): Record<string, string[]> {
-  const survivingPaths = new Set(survivingFiles.map((f) => f.path));
-  return Object.fromEntries(Object.entries(facts).filter(([path]) => survivingPaths.has(path)));
-}
-
-export async function writeCommand(args: WriteArgs): Promise<Result<WriteResult["value"]>> {
-  try {
-    const repoRoot = await findRepoRoot(process.cwd());
-
-    if (args.agent === "external") {
-      // subject is required
-      if (!args.subject) {
-        return { ok: false, error: "subject is required for external agent", code: ErrorCode.INVALID_ARGS };
-      }
-
-      const subjectValidation = validateSubject(args.subject);
-      if (!subjectValidation.ok) return subjectValidation;
-
-      // if content.subject is set but mismatches the subject param → error
-      if (args.content["subject"] !== undefined && args.content["subject"] !== args.subject) {
-        return {
-          ok: false,
-          error: `content.subject "${String(args.content["subject"])}" does not match subject argument "${args.subject}"`,
-          code: ErrorCode.VALIDATION_ERROR,
-        };
-      }
-
-      // inject subject into content if absent
-      const contentWithSubject = { ...args.content, subject: args.subject };
-
-      // validate against ExternalCacheFileSchema
-      const parsed = ExternalCacheFileSchema.safeParse(contentWithSubject);
-      if (!parsed.success) {
-        const message = formatZodError(parsed.error);
-        return { ok: false, error: `Validation failed: ${message}`, code: ErrorCode.VALIDATION_ERROR };
-      }
-
-      const cacheDir = resolveCacheDir("external", repoRoot);
-      const filePath = join(cacheDir, `${args.subject}.json`);
-      const writeResult = await writeCache(filePath, contentWithSubject);
-      if (!writeResult.ok) return writeResult;
-      return { ok: true, value: { file: filePath } };
-    }
-
-    // local — auto-inject server-side timestamp; agent must not control this field
-    const contentWithTimestamp: Record<string, unknown> = {
-      ...args.content,
-      timestamp: new Date().toISOString(),
-    };
-
-    // Resolve real mtimes for submitted tracked_files if present
-    const rawTrackedFiles = contentWithTimestamp["tracked_files"];
-    let survivingSubmitted: TrackedFile[] = [];
-    let guardedPaths = new Set<string>();
-
-    if (Array.isArray(rawTrackedFiles)) {
-      const validEntries = rawTrackedFiles
-        .filter(
-          (entry): entry is { path: string } =>
-            entry !== null &&
-            typeof entry === "object" &&
-            typeof (entry as Record<string, unknown>)["path"] === "string",
-        )
-        .map((entry) => ({ path: entry.path }));
-
-      guardedPaths = new Set(validEntries.map((e) => e.path));
-
-      const resolved = await resolveTrackedFileStats(validEntries, repoRoot);
-      // Evict submitted entries for files that are missing or path-traversal-rejected
-      survivingSubmitted = resolved.filter((f) => f.mtime !== 0);
-    }
-
-    // Guard: submitted facts paths must be a strict subset of submitted tracked_files paths
-    const rawSubmittedFacts = contentWithTimestamp["facts"];
-    if (
-      rawSubmittedFacts !== null &&
-      rawSubmittedFacts !== undefined &&
-      typeof rawSubmittedFacts === "object" &&
-      !Array.isArray(rawSubmittedFacts)
-    ) {
-      const violatingPaths = Object.keys(rawSubmittedFacts as Record<string, string[]>).filter(
-        (p) => !guardedPaths.has(p),
-      );
-      if (violatingPaths.length > 0) {
-        return {
-          ok: false,
-          error: `facts contains paths not in submitted tracked_files: ${violatingPaths.join(", ")}`,
-          code: ErrorCode.VALIDATION_ERROR,
-        };
-      }
-    }
-
-    // Read existing cache to perform per-path merge
-    const localCacheDir = resolveCacheDir("local", repoRoot);
-    const filePath = join(localCacheDir, "context.json");
-
-    const readResult = await readCache(filePath);
-    let existingContent: Record<string, unknown> = {};
-    let existingTrackedFiles: TrackedFile[] = [];
-
-    if (readResult.ok) {
-      existingContent = readResult.value;
-      // Validate the on-disk tracked_files against the schema — fall back to [] on corrupt/missing data
-      const parseResult = TrackedFileSchema.array().safeParse(existingContent["tracked_files"]);
-      existingTrackedFiles = parseResult.success ? parseResult.data : [];
-    } else if (readResult.code !== ErrorCode.FILE_NOT_FOUND) {
-      return { ok: false, error: readResult.error, code: readResult.code };
-    }
-
-    // Keep existing entries whose paths are NOT being replaced by the submitted set
-    const submittedPaths = new Set(survivingSubmitted.map((f) => f.path));
-    const existingNotSubmitted = existingTrackedFiles.filter((f) => !submittedPaths.has(f.path));
-
-    // Evict deleted files from the preserved existing entries
-    const survivingExisting = await filterExistingFiles(existingNotSubmitted, repoRoot);
-
-    const mergedTrackedFiles = [...survivingExisting, ...survivingSubmitted];
-
-    // Per-path merge for facts (mirrors tracked_files merge)
-    const existingFactsRaw = existingContent["facts"];
-    const submittedFactsRaw = contentWithTimestamp["facts"];
-
-    const existingFacts =
-      typeof existingFactsRaw === "object" && existingFactsRaw !== null && !Array.isArray(existingFactsRaw)
-        ? (existingFactsRaw as Record<string, string[]>)
-        : {};
-    const submittedFacts =
-      typeof submittedFactsRaw === "object" && submittedFactsRaw !== null && !Array.isArray(submittedFactsRaw)
-        ? (submittedFactsRaw as Record<string, string[]>)
-        : {};
-
-    const rawMergedFacts = { ...existingFacts, ...submittedFacts };
-    const mergedFacts = evictFactsForDeletedPaths(rawMergedFacts, mergedTrackedFiles);
-
-    // Merge top-level fields: existing base → then submitted content (submitted wins)
-    const processedContent: Record<string, unknown> = {
-      ...existingContent,
-      ...contentWithTimestamp,
-      tracked_files: mergedTrackedFiles,
-      facts: mergedFacts,
-    };
-
-    const parsed = LocalCacheFileSchema.safeParse(processedContent);
-    if (!parsed.success) {
-      const message = formatZodError(parsed.error);
-      return { ok: false, error: `Validation failed: ${message}`, code: ErrorCode.VALIDATION_ERROR };
-    }
-
-    // processedContent is used (not parsed.data) to preserve loose fields not known to the schema — intentional merge semantics
-    const writeResult = await writeCache(filePath, processedContent, "replace");
-    if (!writeResult.ok) return writeResult;
-    return { ok: true, value: { file: filePath } };
-  } catch (err) {
-    const error = err as Error;
-    return { ok: false, error: error.message, code: ErrorCode.UNKNOWN };
-  }
-}