@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/proxy/logIndex.ts

@@ -1,663 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { writeFile, readdir, rename, unlink, open } from "node:fs/promises";
-import { constants, existsSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { Buffer } from "node:buffer";
-import { resolveLogDir, logger } from "./logger";
-import {
-  CapturedLogSchema,
-  type ApiFormat,
-  type CaptureIncompleteReason,
-  type CapturedLog,
-  type StopReason,
-  type ToolTraceEvent,
-} from "./schemas";
-import { textByteLength } from "../lib/unknown";
-import { extractToolTraceEvents } from "../lib/toolTrace";
-import { extractStopReason } from "../lib/stopReason";
-import {
-  getSqliteLogIndexMaxId,
-  listSqliteLogCursorEntries,
-  replaceSqliteLogIndexEntries,
-  syncSqliteLogIndexEntries,
-  upsertSqliteLogIndexEntry,
-} from "./sqliteLogIndex";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-import { recoverCapturedLogStorage } from "./jsonlRecovery";
-import { getSessionArchiveMaxLogId } from "./sessionArchive";
-
-export type LogIndexSummary = {
-  id: number;
-  timestamp: string;
-  method: string;
-  path: string;
-  model: string | null;
-  sessionId: string | null;
-  responseStatus: number | null;
-  inputTokens: number | null;
-  outputTokens: number | null;
-  cacheCreationInputTokens: number | null;
-  cacheReadInputTokens: number | null;
-  elapsedMs: number | null;
-  firstChunkMs: number | null;
-  totalStreamMs: number | null;
-  tokensPerSecond: number | null;
-  streaming: boolean;
-  userAgent: string | null;
-  origin: string | null;
-  apiFormat: ApiFormat;
-  isTest: boolean;
-  replayOfLogId: number | null;
-  providerName: string | null;
-  clientPort: number | null;
-  clientPid: number | null;
-  clientCwd: string | null;
-  clientProjectFolder: string | null;
-  streamingChunksPath: string | null;
-  rawRequestBodyBytes: number | null;
-  responseTextBytes: number | null;
-  captureIncomplete: boolean;
-  droppedChunks: number;
-  droppedBytes: number;
-  captureIncompleteReason: CaptureIncompleteReason | null;
-  warnings?: string[];
-  stopReason: StopReason | null;
-  toolTraceEvents?: ToolTraceEvent[];
-  error: string | null;
-};
-
-export type LogIndexEntry = {
-  id: number;
-  file: string;
-  byteOffset: number;
-  byteLength: number;
-  sessionId?: string | null;
-  model?: string | null;
-  summary?: LogIndexSummary;
-};
-
-export type LogIndexEntryMetadata = {
-  sessionId: string | null;
-  model: string | null;
-  summary: LogIndexSummary;
-};
-
-type LogIndex = {
-  version: number;
-  entries: Record<number, LogIndexEntry>;
-  maxId: number;
-};
-
-const INDEX_VERSION = 1;
-const INDEX_FILE = "logs.idx";
-const INDEX_READ_CHUNK_BYTES = 64 * 1024;
-
-export { resolveLogDir as getLogDir };
-
-function getIndexPath(): string {
-  return join(resolveLogDir(), INDEX_FILE);
-}
-
-let cachedIndex: LogIndex | null = null;
-let allocatedMaxId = 0;
-let sqliteBackfillScheduledMaxId = 0;
-
-export function createLogIndexEntryMetadata(log: CapturedLog): LogIndexEntryMetadata {
-  return {
-    sessionId: log.sessionId,
-    model: log.model,
-    summary: {
-      id: log.id,
-      timestamp: log.timestamp,
-      method: log.method,
-      path: log.path,
-      model: log.model,
-      sessionId: log.sessionId,
-      responseStatus: log.responseStatus,
-      inputTokens: log.inputTokens,
-      outputTokens: log.outputTokens,
-      cacheCreationInputTokens: log.cacheCreationInputTokens,
-      cacheReadInputTokens: log.cacheReadInputTokens,
-      elapsedMs: log.elapsedMs,
-      firstChunkMs: log.firstChunkMs ?? null,
-      totalStreamMs: log.totalStreamMs ?? null,
-      tokensPerSecond: log.tokensPerSecond ?? null,
-      streaming: log.streaming,
-      userAgent: log.userAgent,
-      origin: log.origin,
-      apiFormat: log.apiFormat,
-      isTest: log.isTest ?? false,
-      replayOfLogId: log.replayOfLogId ?? null,
-      providerName: log.providerName ?? null,
-      clientPort: log.clientPort ?? null,
-      clientPid: log.clientPid ?? null,
-      clientCwd: log.clientCwd ?? null,
-      clientProjectFolder: log.clientProjectFolder ?? null,
-      streamingChunksPath: log.streamingChunksPath ?? null,
-      rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
-      responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
-      captureIncomplete: log.captureIncomplete ?? false,
-      droppedChunks: log.droppedChunks ?? 0,
-      droppedBytes: log.droppedBytes ?? 0,
-      captureIncompleteReason: log.captureIncompleteReason ?? null,
-      warnings: log.warnings,
-      stopReason: log.stopReason ?? extractStopReason(log),
-      toolTraceEvents: extractToolTraceEvents(log),
-      error: log.error ?? null,
-    },
-  };
-}
-
-function createEmptyIndex(): LogIndex {
-  return {
-    version: INDEX_VERSION,
-    entries: {},
-    maxId: 0,
-  };
-}
-
-function createIndexFromEntries(entries: readonly LogIndexEntry[]): LogIndex {
-  const index = createEmptyIndex();
-  for (const entry of entries) {
-    index.entries[entry.id] = entry;
-    index.maxId = Math.max(index.maxId, entry.id);
-  }
-  return index;
-}
-
-function sqliteProjectionReferencesExistingLedgers(entries: readonly LogIndexEntry[]): boolean {
-  const logDir = resolveLogDir();
-  for (const entry of entries) {
-    if (!entry.file.endsWith(".jsonl")) return false;
-    if (!existsSync(join(logDir, entry.file))) return false;
-  }
-  return true;
-}
-
-export async function loadIndex(): Promise<LogIndex> {
-  if (cachedIndex !== null) return cachedIndex;
-  const sqliteEntries = await listSqliteLogCursorEntries({});
-  if (sqliteEntries !== null) {
-    if (sqliteProjectionReferencesExistingLedgers(sqliteEntries)) {
-      cachedIndex = createIndexFromEntries(sqliteEntries);
-      allocatedMaxId = Math.max(allocatedMaxId, cachedIndex.maxId);
-      return cachedIndex;
-    }
-    logger.warn("[logIndex] SQLite projection references missing ledgers; rebuilding from JSONL");
-  }
-  // logs.idx remains a legacy fallback projection only. If SQLite is unavailable, rebuild from
-  // authoritative JSONL rather than allowing a stale, conflicting, or higher derived row to win.
-  return await rebuildIndex();
-}
-
-export async function saveIndex(index: LogIndex): Promise<void> {
-  const indexPath = getIndexPath();
-  const dir = dirname(indexPath);
-
-  if (!ensurePrivateDirectorySync(dir)) {
-    logger.error("[logIndex] Failed to secure index directory:", dir);
-    return;
-  }
-
-  const temporaryPath = `${indexPath}.${String(process.pid)}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(temporaryPath, JSON.stringify(index), {
-      encoding: "utf-8",
-      mode: PRIVATE_FILE_MODE,
-    });
-    if (!securePrivateFileSync(temporaryPath)) {
-      await unlink(temporaryPath).catch(() => undefined);
-      logger.error("[logIndex] Failed to secure temporary index file:", temporaryPath);
-      return;
-    }
-    await rename(temporaryPath, indexPath);
-    if (!securePrivateFileSync(indexPath)) {
-      logger.error("[logIndex] Failed to secure index file:", indexPath);
-    }
-  } catch (err) {
-    await unlink(temporaryPath).catch(() => undefined);
-    logger.error("[logIndex] Failed to save index:", String(err));
-  }
-}
-
-export async function addToIndex(
-  id: number,
-  file: string,
-  byteOffset: number,
-  byteLength: number,
-  metadata?: LogIndexEntryMetadata,
-): Promise<void> {
-  const index = await loadIndex();
-  const entry: LogIndexEntry =
-    metadata === undefined
-      ? { id, file, byteOffset, byteLength }
-      : { id, file, byteOffset, byteLength, ...metadata };
-  index.entries[id] = entry;
-  if (id > index.maxId) {
-    index.maxId = id;
-  }
-  const sqliteUpdated = await upsertSqliteLogIndexEntry(entry);
-  if (!sqliteUpdated) {
-    // Legacy fallback only: defer disk writes to reduce I/O when SQLite is unavailable.
-    scheduleIndexFlush();
-  }
-}
-
-/**
- * Refresh the searchable summary after a request reaches its terminal state. The initial index
- * entry is created before the upstream call starts, so leaving it untouched would make compact
- * reads (and the SQLite sidecar) report the pre-request placeholder after finalization.
- */
-export async function updateLogIndexEntryMetadata(log: CapturedLog): Promise<void> {
-  const index = await loadIndex();
-  const existing = index.entries[log.id];
-  if (existing === undefined) return;
-
-  const updated: LogIndexEntry = {
-    ...existing,
-    ...createLogIndexEntryMetadata(log),
-  };
-  index.entries[log.id] = updated;
-  const sqliteUpdated = await upsertSqliteLogIndexEntry(updated);
-  if (!sqliteUpdated) scheduleIndexFlush();
-}
-
-// Batch writes: collect pending flushes and write once
-let indexFlushScheduled = false;
-let indexFlushTimeout: ReturnType<typeof setTimeout> | null = null;
-
-async function flushIndexAsync(): Promise<void> {
-  indexFlushScheduled = false;
-  indexFlushTimeout = null;
-  if ((await listSqliteLogCursorEntries({})) !== null) return;
-  const index = await loadIndex();
-  await saveIndex(index);
-}
-
-function scheduleIndexFlush(): void {
-  if (indexFlushScheduled) return;
-  indexFlushScheduled = true;
-  indexFlushTimeout = setTimeout(() => {
-    void flushIndexAsync();
-  }, 1000); // Flush after 1 second of inactivity
-}
-
-export async function flushIndex(): Promise<void> {
-  if (indexFlushTimeout !== null) {
-    clearTimeout(indexFlushTimeout);
-    indexFlushTimeout = null;
-  }
-  indexFlushScheduled = false;
-  if ((await listSqliteLogCursorEntries({})) !== null) return;
-  const index = await loadIndex();
-  await saveIndex(index);
-}
-
-export async function findInIndex(id: number): Promise<LogIndexEntry | null> {
-  const index = await loadIndex();
-  return index.entries[id] ?? null;
-}
-
-export async function listIndexEntries(): Promise<LogIndexEntry[]> {
-  const index = await loadIndex();
-  const sqliteMaxId = await getSqliteLogIndexMaxId();
-  maybeBackfillSqliteIndex(index, sqliteMaxId);
-  return Object.values(index.entries).sort((left, right) => left.id - right.id);
-}
-
-export async function listFilteredIndexEntries({
-  sessionId,
-  model,
-}: {
-  sessionId?: string;
-  model?: string;
-}): Promise<LogIndexEntry[]> {
-  const index = await loadIndex();
-  const sqliteMaxId = await getSqliteLogIndexMaxId();
-  maybeBackfillSqliteIndex(index, sqliteMaxId);
-  return Object.values(index.entries)
-    .sort((left, right) => left.id - right.id)
-    .filter((entry) => {
-      if (sessionId !== undefined && entry.sessionId !== sessionId) return false;
-      if (model !== undefined && entry.model !== model) return false;
-      return true;
-    });
-}
-
-function maybeBackfillSqliteIndex(index: LogIndex, sqliteMaxId: number | null): void {
-  if (sqliteMaxId === null) return;
-  if (index.maxId <= sqliteMaxId) return;
-  if (index.maxId <= sqliteBackfillScheduledMaxId) return;
-
-  sqliteBackfillScheduledMaxId = index.maxId;
-  const entries = Object.values(index.entries);
-  void syncSqliteLogIndexEntries(entries).then((ok) => {
-    if (!ok && sqliteMaxId < sqliteBackfillScheduledMaxId) {
-      sqliteBackfillScheduledMaxId = sqliteMaxId;
-    }
-  });
-}
-
-type FileIndexResult = {
-  entries: Record<number, LogIndexEntry>;
-  maxId: number;
-};
-
-type ParsedIndexRecord =
-  | { status: "blank" }
-  | { status: "log"; log: CapturedLog }
-  | { status: "invalid"; message: string };
-
-function readStringOrNullField(entry: object, field: string): string | null {
-  const desc = Object.getOwnPropertyDescriptor(entry, field);
-  if (desc === undefined) return null;
-  if (typeof desc.value === "string") return desc.value;
-  return null;
-}
-
-function readStringField(entry: object, field: string): string {
-  return readStringOrNullField(entry, field) ?? "";
-}
-
-function readNumberOrNullField(entry: object, field: string): number | null {
-  const desc = Object.getOwnPropertyDescriptor(entry, field);
-  if (desc === undefined) return null;
-  return typeof desc.value === "number" ? desc.value : null;
-}
-
-function readBooleanField(entry: object, field: string): boolean {
-  const desc = Object.getOwnPropertyDescriptor(entry, field);
-  if (desc === undefined) return false;
-  return typeof desc.value === "boolean" ? desc.value : false;
-}
-
-function readApiFormatField(entry: object): ApiFormat {
-  const value = readStringOrNullField(entry, "apiFormat");
-  switch (value) {
-    case "anthropic":
-      return "anthropic";
-    case "openai":
-      return "openai";
-    case "unknown":
-    case null:
-      return "unknown";
-    default:
-      return "unknown";
-  }
-}
-
-function readCaptureIncompleteReasonField(entry: object): CaptureIncompleteReason | null {
-  const value = readStringOrNullField(entry, "captureIncompleteReason");
-  switch (value) {
-    case "capacity-exceeded":
-    case "pipeline-closed":
-    case "write-failed":
-    case "finalize-failed":
-    case "upstream-stream-error":
-    case "shutdown":
-      return value;
-    case null:
-    default:
-      return null;
-  }
-}
-
-function readStopReasonField(entry: object): StopReason | null {
-  const value = readStringOrNullField(entry, "stopReason");
-  switch (value) {
-    case "end_turn":
-    case "tool_use":
-    case "stop":
-    case "length":
-      return value;
-    case null:
-    default:
-      return null;
-  }
-}
-
-function readStringArrayField(entry: object, field: string): string[] | undefined {
-  const desc = Object.getOwnPropertyDescriptor(entry, field);
-  if (desc === undefined || !Array.isArray(desc.value)) return undefined;
-
-  const values: string[] = [];
-  for (const item of desc.value) {
-    if (typeof item !== "string") return undefined;
-    values.push(item);
-  }
-  return values;
-}
-
-function readTextByteLength(entry: object, bytesField: string, textField: string): number | null {
-  const explicitBytes = readNumberOrNullField(entry, bytesField);
-  if (explicitBytes !== null && explicitBytes >= 0) return explicitBytes;
-  return textByteLength(readStringOrNullField(entry, textField));
-}
-
-function readLogIndexSummary(entry: object, id: number): LogIndexSummary {
-  return {
-    id,
-    timestamp: readStringField(entry, "timestamp"),
-    method: readStringField(entry, "method"),
-    path: readStringField(entry, "path"),
-    model: readStringOrNullField(entry, "model"),
-    sessionId: readStringOrNullField(entry, "sessionId"),
-    responseStatus: readNumberOrNullField(entry, "responseStatus"),
-    inputTokens: readNumberOrNullField(entry, "inputTokens"),
-    outputTokens: readNumberOrNullField(entry, "outputTokens"),
-    cacheCreationInputTokens: readNumberOrNullField(entry, "cacheCreationInputTokens"),
-    cacheReadInputTokens: readNumberOrNullField(entry, "cacheReadInputTokens"),
-    elapsedMs: readNumberOrNullField(entry, "elapsedMs"),
-    firstChunkMs: readNumberOrNullField(entry, "firstChunkMs"),
-    totalStreamMs: readNumberOrNullField(entry, "totalStreamMs"),
-    tokensPerSecond: readNumberOrNullField(entry, "tokensPerSecond"),
-    streaming: readBooleanField(entry, "streaming"),
-    userAgent: readStringOrNullField(entry, "userAgent"),
-    origin: readStringOrNullField(entry, "origin"),
-    apiFormat: readApiFormatField(entry),
-    isTest: readBooleanField(entry, "isTest"),
-    replayOfLogId: readNumberOrNullField(entry, "replayOfLogId"),
-    providerName: readStringOrNullField(entry, "providerName"),
-    clientPort: readNumberOrNullField(entry, "clientPort"),
-    clientPid: readNumberOrNullField(entry, "clientPid"),
-    clientCwd: readStringOrNullField(entry, "clientCwd"),
-    clientProjectFolder: readStringOrNullField(entry, "clientProjectFolder"),
-    streamingChunksPath: readStringOrNullField(entry, "streamingChunksPath"),
-    rawRequestBodyBytes: readTextByteLength(entry, "rawRequestBodyBytes", "rawRequestBody"),
-    responseTextBytes: readTextByteLength(entry, "responseTextBytes", "responseText"),
-    captureIncomplete: readBooleanField(entry, "captureIncomplete"),
-    droppedChunks: readNumberOrNullField(entry, "droppedChunks") ?? 0,
-    droppedBytes: readNumberOrNullField(entry, "droppedBytes") ?? 0,
-    captureIncompleteReason: readCaptureIncompleteReasonField(entry),
-    warnings: readStringArrayField(entry, "warnings"),
-    stopReason: readStopReasonField(entry),
-    error: readStringOrNullField(entry, "error"),
-  };
-}
-
-function parseIndexRecord(record: Buffer, file: string, byteOffset: number): ParsedIndexRecord {
-  const content =
-    record.length > 0 && record[record.length - 1] === 0x0d ? record.subarray(0, -1) : record;
-  const line = content.toString("utf-8");
-  if (line.trim() === "") return { status: "blank" };
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(line);
-  } catch (error) {
-    return {
-      status: "invalid",
-      message: `Malformed JSONL record in ${file} at byte ${String(byteOffset)}: ${String(error)}`,
-    };
-  }
-  const validated = CapturedLogSchema.safeParse(parsed);
-  return validated.success
-    ? { status: "log", log: validated.data }
-    : {
-        status: "invalid",
-        message: `Invalid captured-log record in ${file} at byte ${String(byteOffset)}`,
-      };
-}
-
-function addIndexedRecord(
-  result: FileIndexResult,
-  parsed: ParsedIndexRecord,
-  file: string,
-  byteOffset: number,
-  byteLength: number,
-): Error | null {
-  switch (parsed.status) {
-    case "blank":
-      return null;
-    case "invalid":
-      return new Error(parsed.message);
-    case "log": {
-      const entry = parsed.log;
-      result.maxId = Math.max(result.maxId, entry.id);
-      result.entries[entry.id] = {
-        id: entry.id,
-        file,
-        byteOffset,
-        byteLength,
-        sessionId: entry.sessionId,
-        model: entry.model,
-        summary: readLogIndexSummary(entry, entry.id),
-      };
-      return null;
-    }
-  }
-}
-
-async function indexFile(filePath: string, file: string): Promise<FileIndexResult> {
-  const result: FileIndexResult = { entries: {}, maxId: 0 };
-  let handle: Awaited<ReturnType<typeof open>> | null = null;
-  try {
-    handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
-    const fileStats = await handle.stat();
-    if (!fileStats.isFile()) {
-      return await Promise.reject(new Error(`Captured-log ledger is not a regular file: ${file}`));
-    }
-
-    const readBuffer = Buffer.alloc(INDEX_READ_CHUNK_BYTES);
-    let position = 0;
-    let pending = Buffer.alloc(0);
-    let pendingOffset = 0;
-    while (position < fileStats.size) {
-      const length = Math.min(INDEX_READ_CHUNK_BYTES, fileStats.size - position);
-      const read = await handle.read(readBuffer, 0, length, position);
-      if (read.bytesRead === 0) {
-        return await Promise.reject(
-          new Error(`Captured-log ledger changed while rebuilding index: ${file}`),
-        );
-      }
-      const chunk = readBuffer.subarray(0, read.bytesRead);
-      const combined = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, chunk]);
-      let consumed = 0;
-      let newline = combined.indexOf(0x0a, consumed);
-      while (newline !== -1) {
-        const record = combined.subarray(consumed, newline);
-        const byteOffset = pendingOffset + consumed;
-        const byteLength = record.length + 1;
-        const error = addIndexedRecord(
-          result,
-          parseIndexRecord(record, file, byteOffset),
-          file,
-          byteOffset,
-          byteLength,
-        );
-        if (error !== null) return await Promise.reject(error);
-        consumed = newline + 1;
-        newline = combined.indexOf(0x0a, consumed);
-      }
-      pending = Buffer.from(combined.subarray(consumed));
-      pendingOffset += consumed;
-      position += read.bytesRead;
-    }
-
-    if (pending.length > 0) {
-      return await Promise.reject(
-        new Error(`Captured-log ledger ended without recovery delimiter: ${file}`),
-      );
-    }
-    return result;
-  } finally {
-    await handle?.close().catch(() => undefined);
-  }
-}
-
-export async function rebuildIndex(): Promise<LogIndex> {
-  const logDir = resolveLogDir();
-  const newIndex = createEmptyIndex();
-  const recovery = await recoverCapturedLogStorage(logDir);
-  if (recovery.level === "unavailable") {
-    return await Promise.reject(
-      new Error(recovery.diagnostic ?? "Captured-log recovery blocked index rebuild"),
-    );
-  }
-
-  if (!existsSync(logDir)) {
-    cachedIndex = newIndex;
-    allocatedMaxId = 0;
-    await saveIndex(newIndex);
-    await replaceSqliteLogIndexEntries([]);
-    return newIndex;
-  }
-
-  const files = (await readdir(logDir)).filter((f) => f.endsWith(".jsonl")).sort();
-  const CONCURRENCY = 4;
-
-  // Process files in bounded-concurrency batches
-  for (let i = 0; i < files.length; i += CONCURRENCY) {
-    const batch = files.slice(i, i + CONCURRENCY);
-    const results = await Promise.all(batch.map((file) => indexFile(join(logDir, file), file)));
-
-    for (const result of results) {
-      Object.assign(newIndex.entries, result.entries);
-      newIndex.maxId = Math.max(newIndex.maxId, result.maxId);
-    }
-  }
-
-  cachedIndex = newIndex;
-  allocatedMaxId = Math.max(allocatedMaxId, newIndex.maxId);
-  await saveIndex(newIndex);
-  await replaceSqliteLogIndexEntries(Object.values(newIndex.entries));
-  return newIndex;
-}
-
-// Promise-chaining queue for atomic ID generation. Each caller chains on the
-// previous promise, guaranteeing mutual exclusion without the broken
-// releaseLock pattern that allowed concurrent entry when 3+ callers waited.
-let idGenerationChain: Promise<void> = Promise.resolve();
-
-async function withIdLock<T>(fn: () => Promise<T>): Promise<T> {
-  const run = idGenerationChain.then(fn);
-  // Keep the chain alive regardless of success/failure so the next caller
-  // never sees a rejected antecedent.
-  idGenerationChain = run.then(
-    () => {},
-    () => {},
-  );
-  return run;
-}
-
-export async function getNextLogId(): Promise<number> {
-  return withIdLock(async () => {
-    const index = await loadIndex();
-    const archiveMaxId = await getSessionArchiveMaxLogId();
-    const nextId = Math.max(index.maxId, archiveMaxId, allocatedMaxId) + 1;
-    allocatedMaxId = nextId;
-    return nextId;
-  });
-}
-
-export function getCurrentLogFile(): string {
-  const now = new Date();
-  const yyyy = now.getUTCFullYear();
-  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
-  const dd = String(now.getUTCDate()).padStart(2, "0");
-  return `${yyyy}-${mm}-${dd}.jsonl`;
-}