chainlesschain 0.165.2 → 0.165.4

package/src/lib/session-budget-production-root.js

@@ -0,0 +1,376 @@
+import {
+  openSessionBudget,
+  SessionBudgetSidecarStore,
+} from "./session-budget-runtime.js";
+import {
+  normalizeSessionResourceBudgetSnapshot,
+  SESSION_BUDGET_RECOVERY_RECEIPT_HISTORY_SCHEMA,
+} from "./session-resource-budget.js";
+
+export const SESSION_BUDGET_ROOT_SCHEMA =
+  "chainlesschain.session-budget-root/v1";
+
+const OPTION_FIELDS = Object.freeze([
+  ["sessionMaxConcurrent", "maxConcurrent", "--session-max-concurrent", true],
+  ["sessionMaxSpawns", "maxSpawns", "--session-max-spawns", true],
+  ["sessionMaxDepth", "maxDepth", "--session-max-depth", true],
+  ["sessionMaxTurns", "maxTurns", "--session-max-turns", true],
+  ["sessionMaxTokens", "maxTokens", "--session-max-tokens", true],
+  ["sessionMaxCostUsd", "maxUsd", "--session-max-cost-usd", false],
+  ["sessionMaxWallMs", "maxWallMs", "--session-max-wall-ms", true],
+  ["sessionMaxToolMs", "maxToolMs", "--session-max-tool-ms", true],
+]);
+
+const LIMIT_FIELDS = Object.freeze(
+  OPTION_FIELDS.map(([, field, flag, integer]) => ({
+    field,
+    flag,
+    integer,
+  })),
+);
+
+function normalizeLimit(raw, flag, { integer, allowZero = false } = {}) {
+  if (raw === undefined || raw === null || raw === "") return null;
+  const value = Number(raw);
+  if (
+    !Number.isFinite(value) ||
+    (allowZero ? value < 0 : value <= 0) ||
+    (integer && !Number.isSafeInteger(value))
+  ) {
+    throw new TypeError(
+      `${flag} requires ${allowZero ? "a non-negative" : "a positive"}${integer ? " integer" : " number"}`,
+    );
+  }
+  return value;
+}
+
+export function resolveSessionBudgetRootOptions(options = {}) {
+  const limits = {};
+  let hasLimit = false;
+  for (const [optionName, field, flag, integer] of OPTION_FIELDS) {
+    const value = normalizeLimit(options[optionName], flag, {
+      integer,
+      allowZero: field === "maxDepth",
+    });
+    if (value !== null) {
+      limits[field] = value;
+      hasLimit = true;
+    }
+  }
+  return Object.freeze({
+    schema: SESSION_BUDGET_ROOT_SCHEMA,
+    enabled: options.sessionBudget === true || hasLimit,
+    limits: Object.freeze(limits),
+  });
+}
+
+export function normalizeSessionBudgetRootConfig(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    const error = new TypeError("session budget root config must be an object");
+    error.code = "CC_SESSION_BUDGET_CONFIG_INVALID";
+    throw error;
+  }
+  try {
+    if (config.schema !== SESSION_BUDGET_ROOT_SCHEMA) {
+      throw new TypeError("session budget root schema is unsupported");
+    }
+    if (typeof config.enabled !== "boolean") {
+      throw new TypeError("session budget root enabled flag is invalid");
+    }
+    if (
+      !config.limits ||
+      typeof config.limits !== "object" ||
+      Array.isArray(config.limits)
+    ) {
+      throw new TypeError("session budget root limits must be an object");
+    }
+    const allowed = new Set(LIMIT_FIELDS.map(({ field }) => field));
+    if (Object.keys(config.limits).some((field) => !allowed.has(field))) {
+      throw new TypeError("session budget root contains an unknown limit");
+    }
+    const limits = {};
+    for (const { field, flag, integer } of LIMIT_FIELDS) {
+      const value = normalizeLimit(config.limits[field], flag, {
+        integer,
+        allowZero: field === "maxDepth",
+      });
+      if (value !== null) limits[field] = value;
+    }
+    if (!config.enabled && Object.keys(limits).length > 0) {
+      throw new TypeError("disabled session budget root cannot contain limits");
+    }
+    return Object.freeze({
+      schema: SESSION_BUDGET_ROOT_SCHEMA,
+      enabled: config.enabled,
+      limits: Object.freeze(limits),
+    });
+  } catch (error) {
+    error.code ||= "CC_SESSION_BUDGET_CONFIG_INVALID";
+    throw error;
+  }
+}
+
+function combineSignals(...signals) {
+  const active = signals.filter(Boolean);
+  if (active.length === 0) return null;
+  if (active.length === 1) return active[0];
+  return AbortSignal.any(active);
+}
+
+function budgetRootError(code, message, extra = {}) {
+  const error = new Error(message);
+  error.code = code;
+  Object.assign(error, extra);
+  return error;
+}
+
+export function openProductionSessionBudgetRoot(
+  sessionId,
+  config,
+  {
+    persist = false,
+    signal = null,
+    table = undefined,
+    open = openSessionBudget,
+    store = undefined,
+    registry = undefined,
+  } = {},
+) {
+  if (config?.enabled !== true) {
+    return Object.freeze({
+      enabled: false,
+      options: Object.freeze({}),
+      close: () => false,
+    });
+  }
+  if (!persist || !sessionId) {
+    throw budgetRootError(
+      "CC_SESSION_BUDGET_REQUIRES_DURABLE_SESSION",
+      "session budget root requires a durable --session/--resume/--continue target",
+    );
+  }
+  if (typeof open !== "function") {
+    throw new TypeError("session budget root requires an opener");
+  }
+
+  const handle = open(String(sessionId), {
+    limits: config.limits || {},
+    table,
+    ...(store ? { store } : {}),
+    ...(registry ? { registry } : {}),
+  });
+  let closed = false;
+  try {
+    const status = handle.status();
+    if (status.recoveryRequired) {
+      throw budgetRootError(
+        "CC_SESSION_BUDGET_RECOVERY_REQUIRED",
+        `session budget recovery is required for ${sessionId}; inspect it with \`cc session budget status ${sessionId}\``,
+        {
+          sessionId: String(sessionId),
+          pendingRecovery: status.pendingRecovery,
+        },
+      );
+    }
+    const combinedSignal = combineSignals(signal, handle.budget.signal);
+    return Object.freeze({
+      enabled: true,
+      sessionId: String(sessionId),
+      handle,
+      budget: handle.budget,
+      options: Object.freeze({
+        sessionBudget: handle.budget,
+        ...(combinedSignal ? { signal: combinedSignal } : {}),
+      }),
+      close() {
+        if (closed) return false;
+        closed = true;
+        return handle.close();
+      },
+    });
+  } catch (error) {
+    if (!closed) {
+      closed = true;
+      try {
+        handle.close();
+      } catch {
+        // Preserve the admission/recovery failure that prevented dispatch.
+      }
+    }
+    throw error;
+  }
+}
+
+function projectPending(snapshot) {
+  return [
+    ...snapshot.inFlight.work.map((entry) => ({
+      authorityId: entry.id,
+      resourceType: "work",
+      kind: entry.kind,
+      ...(entry.depth !== undefined ? { depth: entry.depth } : {}),
+      ...(entry.elapsedMs !== undefined ? { elapsedMs: entry.elapsedMs } : {}),
+    })),
+    ...snapshot.inFlight.tools.map((entry) => ({
+      authorityId: entry.id,
+      resourceType: "tool",
+      kind: entry.kind,
+      ...(entry.elapsedMs !== undefined ? { elapsedMs: entry.elapsedMs } : {}),
+    })),
+  ].sort((left, right) => left.authorityId.localeCompare(right.authorityId));
+}
+
+function projectRecoveryAdjudication(value) {
+  if (!value) return null;
+  return Object.freeze({
+    schema: value.schema,
+    count: value.count,
+    headDigest: value.headDigest,
+    last: Object.freeze({ ...value.last }),
+    ...(value.history
+      ? {
+          history: Object.freeze({
+            schema: value.history.schema,
+            baseSequence: value.history.baseSequence,
+            baseDigest: value.history.baseDigest,
+            retainedCount: value.history.entries.length,
+            complete: value.history.baseSequence === 0,
+          }),
+        }
+      : {}),
+  });
+}
+
+export function readProductionSessionBudget(
+  sessionId,
+  { store = new SessionBudgetSidecarStore() } = {},
+) {
+  const record = store.read(String(sessionId));
+  if (!record) return null;
+  const snapshot = normalizeSessionResourceBudgetSnapshot(record.snapshot);
+  const pending = projectPending(snapshot);
+  return Object.freeze({
+    schema: SESSION_BUDGET_ROOT_SCHEMA,
+    sessionId: String(sessionId),
+    revision: record.revision,
+    usageUnknown: record.usageUnknown === true,
+    limits: Object.freeze({ ...snapshot.limits }),
+    totals: Object.freeze({ ...snapshot.totals }),
+    state: Object.freeze({
+      started: snapshot.state.started,
+      abort: snapshot.state.abort
+        ? Object.freeze({ ...snapshot.state.abort })
+        : null,
+      recoveryAdjudication: projectRecoveryAdjudication(
+        snapshot.state.recoveryAdjudication,
+      ),
+    }),
+    recoveryRequired: pending.length > 0,
+    pendingRecovery: Object.freeze(
+      pending.map((entry) => Object.freeze(entry)),
+    ),
+  });
+}
+
+export function readProductionSessionBudgetRecoveryReceipts(
+  sessionId,
+  { store = new SessionBudgetSidecarStore() } = {},
+) {
+  const normalizedSessionId = String(sessionId);
+  const record = store.read(normalizedSessionId);
+  if (!record) return null;
+  const snapshot = normalizeSessionResourceBudgetSnapshot(record.snapshot);
+  const adjudication = snapshot.state.recoveryAdjudication;
+  const history = adjudication?.history || null;
+  const entries = history?.entries || [];
+  return Object.freeze({
+    schema: SESSION_BUDGET_RECOVERY_RECEIPT_HISTORY_SCHEMA,
+    sessionId: normalizedSessionId,
+    revision: record.revision,
+    count: adjudication?.count || 0,
+    headDigest: adjudication?.headDigest || null,
+    baseSequence: history?.baseSequence ?? adjudication?.count ?? 0,
+    baseDigest: history
+      ? history.baseDigest
+      : adjudication?.headDigest || null,
+    complete: adjudication
+      ? Boolean(history && history.baseSequence === 0)
+      : true,
+    entries: Object.freeze(
+      entries.map((entry) => Object.freeze(structuredClone(entry))),
+    ),
+  });
+}
+
+export function adjudicateProductionSessionBudgetRecovery(
+  sessionId,
+  adjudication,
+  {
+    store = new SessionBudgetSidecarStore(),
+    registry = new Map(),
+    open = openSessionBudget,
+  } = {},
+) {
+  const request = Array.isArray(adjudication)
+    ? { abandoned: adjudication, settled: [] }
+    : adjudication && typeof adjudication === "object"
+      ? {
+          abandoned: adjudication.abandoned || [],
+          settled: adjudication.settled || [],
+        }
+      : { abandoned: [], settled: [] };
+  if (request.abandoned.length === 0 && request.settled.length === 0) {
+    throw budgetRootError(
+      "CC_SESSION_BUDGET_RECOVERY_IDS_REQUIRED",
+      "session budget recovery requires every exact authority id as --abandon or --settlement",
+    );
+  }
+  const handle = open(String(sessionId), { store, registry });
+  let result;
+  try {
+    const pending = handle.budget.pendingRecovery();
+    if (pending.length === 0) {
+      throw budgetRootError(
+        "CC_SESSION_BUDGET_RECOVERY_NOT_REQUIRED",
+        `session budget recovery is not required for ${sessionId}`,
+      );
+    }
+    result = handle.budget.adjudicateRecovery(request);
+    if (!result.ok) {
+      throw budgetRootError(
+        "CC_SESSION_BUDGET_RECOVERY_INCOMPLETE",
+        "session budget recovery requires the exact pending authority-id set",
+        { pending: result.pending },
+      );
+    }
+    return Object.freeze({
+      schema: SESSION_BUDGET_ROOT_SCHEMA,
+      sessionId: String(sessionId),
+      abandoned: Object.freeze([...result.abandoned]),
+      settled: Object.freeze([...result.settled]),
+      adjudication: Object.freeze({ ...result.adjudication }),
+      receipt: Object.freeze(structuredClone(result.receipt)),
+      status: Object.freeze({ ...handle.status() }),
+    });
+  } finally {
+    handle.close();
+  }
+}
+
+export function sessionBudgetAdmissionError(reason, operation) {
+  return budgetRootError(
+    "CC_SESSION_BUDGET_EXHAUSTED",
+    `session budget blocked ${operation}: ${reason || "session-aborted"}`,
+    { budgetReason: reason || "session-aborted" },
+  );
+}
+
+export function sessionBudgetUsageUnknownError(operation, callId = null) {
+  return budgetRootError(
+    "CC_SESSION_BUDGET_USAGE_UNKNOWN",
+    `session budget requires usage adjudication after ${operation}`,
+    {
+      budgetReason: "provider-usage-unknown",
+      ...(callId ? { callId: String(callId) } : {}),
+    },
+  );
+}

package/src/lib/session-budget-runtime.js

@@ -206,12 +206,29 @@ function mergeUsageUnknownSnapshot(baseSnapshot, markerSnapshot, filePath) {
   const work = new Map(base.inFlight.work.map((entry) => [entry.id, entry]));
   for (const entry of markerEntries) {
     const existing = work.get(entry.id);
-    if (existing && JSON.stringify(existing) !== JSON.stringify(entry)) {
-      throw runtimeError(
-        "corrupt",
-        filePath,
-        new TypeError("conflicting usage-unknown settlement identity"),
-      );
+    if (existing) {
+      if (
+        existing.kind !== entry.kind ||
+        (existing.depth ?? null) !== (entry.depth ?? null)
+      ) {
+        throw runtimeError(
+          "corrupt",
+          filePath,
+          new TypeError("conflicting usage-unknown settlement identity"),
+        );
+      }
+      work.set(entry.id, {
+        ...existing,
+        ...(existing.elapsedMs !== undefined || entry.elapsedMs !== undefined
+          ? {
+              elapsedMs: Math.max(
+                Number(existing.elapsedMs || 0),
+                Number(entry.elapsedMs || 0),
+              ),
+            }
+          : {}),
+      });
+      continue;
     }
     work.set(entry.id, { ...entry });
     if (work.size + base.inFlight.tools.length > MAX_IN_FLIGHT_RESOURCES) {
@@ -879,14 +896,6 @@ export class SessionBudgetSidecarStore {
             "ERR_SESSION_BUDGET_MARKER_CONFLICT",
           );
         }
-        if (resolveUsageUnknown && !clean) {
-          throw runtimeError(
-            "recovery",
-            filePath,
-            new Error("usage finalization snapshot must be clean"),
-            "ERR_SESSION_BUDGET_RECOVERY_REQUIRED",
-          );
-        }
         const actualRevision = current?.revision ?? null;
         if (actualRevision !== expectedRevision) {
           throw runtimeError(
@@ -916,13 +925,24 @@ export class SessionBudgetSidecarStore {
           snapshot: canonicalSnapshot,
         };
         writeRecordAt(filePath, record, this._fs, this._ioOptions);
+        let nextUsageUnknownMarker = null;
         if (resolveUsageUnknown) {
-          this._clearUsageUnknownLocked(id, expectedMarker);
+          if (clean) {
+            this._clearUsageUnknownLocked(id, expectedMarker);
+          } else {
+            nextUsageUnknownMarker = this._replaceUsageUnknownLocked(
+              id,
+              canonicalSnapshot,
+              expectedMarker,
+            );
+          }
         }
         return {
           revision,
           filePath,
-          ...(resolveUsageUnknown ? { usageUnknownMarker: null } : {}),
+          ...(resolveUsageUnknown
+            ? { usageUnknownMarker: nextUsageUnknownMarker }
+            : {}),
         };
       },
       {
@@ -935,7 +955,11 @@ export class SessionBudgetSidecarStore {
     return result;
   }
 
-  markUsageUnknown(sessionId, snapshot) {
+  markUsageUnknown(
+    sessionId,
+    snapshot,
+    { expectedUsageUnknownMarker = null } = {},
+  ) {
     const id = String(sessionId);
     const filePath = this.pathForSession(id);
     this._assertSupported(filePath);
@@ -945,6 +969,12 @@ export class SessionBudgetSidecarStore {
       markerPath,
       "snapshot",
     );
+    const expectedMarker = expectedUsageUnknownMarker
+      ? normalizeUsageUnknownMarkerIdentity(
+          expectedUsageUnknownMarker,
+          markerPath,
+        )
+      : null;
     if (usageSettlementEntries(canonicalSnapshot).length === 0) {
       throw runtimeError(
         "marker",
@@ -965,6 +995,18 @@ export class SessionBudgetSidecarStore {
       filePath,
       () => {
         const current = readRecordAt(markerPath, id, this._fs, this._ioOptions);
+        const actualMarker = usageUnknownMarkerIdentity(current);
+        const markerMatches = current
+          ? sameUsageUnknownMarkerIdentity(expectedMarker, actualMarker)
+          : expectedMarker === null;
+        if (!current && !markerMatches) {
+          throw runtimeError(
+            "conflict",
+            markerPath,
+            new Error("usage-unknown marker disappeared after it was observed"),
+            "ERR_SESSION_BUDGET_MARKER_CONFLICT",
+          );
+        }
         if (current?.revision === Number.MAX_SAFE_INTEGER) {
           throw runtimeError(
             "revision",
@@ -997,7 +1039,7 @@ export class SessionBudgetSidecarStore {
           this._ioOptions,
         );
         const usageUnknownMarker = usageUnknownMarkerIdentity(committed);
-        if (current) {
+        if (!markerMatches) {
           // Preserve the newly reported settlement, but do not let a runtime
           // that did not observe the prior marker later finalize both. The
           // caller fails closed and a fresh recovery host must see the union.
@@ -1019,6 +1061,52 @@ export class SessionBudgetSidecarStore {
     );
   }
 
+  _replaceUsageUnknownLocked(sessionId, snapshot, expectedMarker) {
+    const id = String(sessionId);
+    const markerPath = this.usageUnknownPathForSession(id);
+    const marker = readRecordAt(markerPath, id, this._fs, this._ioOptions);
+    const actualMarker = usageUnknownMarkerIdentity(marker);
+    if (!sameUsageUnknownMarkerIdentity(expectedMarker, actualMarker)) {
+      throw runtimeError(
+        "conflict",
+        markerPath,
+        new Error("usage-unknown marker changed before settlement"),
+        "ERR_SESSION_BUDGET_MARKER_CONFLICT",
+      );
+    }
+    if (marker.revision === Number.MAX_SAFE_INTEGER) {
+      throw runtimeError(
+        "revision",
+        markerPath,
+        new Error("usage-unknown marker revision is exhausted"),
+        "ERR_SESSION_BUDGET_UNSAFE_REVISION",
+      );
+    }
+    const canonicalSnapshot = canonicalizeSnapshot(
+      snapshot,
+      markerPath,
+      "snapshot",
+    );
+    if (usageSettlementEntries(canonicalSnapshot).length === 0) {
+      throw runtimeError(
+        "marker",
+        markerPath,
+        new TypeError("usage-unknown marker requires a pending settlement"),
+      );
+    }
+    const record = {
+      version: SESSION_BUDGET_SIDECAR_VERSION,
+      sessionId: id,
+      revision: marker.revision + 1,
+      storedAt: new Date(this._now()).toISOString(),
+      writer: { pid: process.pid },
+      snapshot: canonicalSnapshot,
+    };
+    writeRecordAt(markerPath, record, this._fs, this._ioOptions);
+    const committed = readRecordAt(markerPath, id, this._fs, this._ioOptions);
+    return usageUnknownMarkerIdentity(committed);
+  }
+
   clearUsageUnknown(sessionId, { expectedUsageUnknownMarker = null } = {}) {
     const id = String(sessionId);
     const filePath = this.pathForSession(id);
@@ -1194,6 +1282,9 @@ class SharedSessionBudgetRuntime {
         const marker = this.store.markUsageUnknown(
           this.sessionId,
           change.snapshot,
+          {
+            expectedUsageUnknownMarker: this.usageUnknownMarker,
+          },
         );
         const usageUnknownMarker = normalizeUsageUnknownMarkerIdentity(
           marker?.usageUnknownMarker,

package/src/lib/session-budget-usage.js

@@ -0,0 +1,63 @@
+import {
+  sessionBudgetAdmissionError,
+  sessionBudgetUsageUnknownError,
+} from "./session-budget-production-root.js";
+
+function isRootUsage(event) {
+  return !event?.attribution;
+}
+
+export function beginSessionBudgetUsage(
+  sessionBudget,
+  event,
+  operation = "provider usage",
+) {
+  if (
+    !isRootUsage(event) ||
+    typeof sessionBudget?.beginUsageSettlement !== "function"
+  ) {
+    return null;
+  }
+  const admission = sessionBudget.beginUsageSettlement({ id: event.callId });
+  if (!admission?.ok) {
+    throw sessionBudgetAdmissionError(admission?.reason, operation);
+  }
+  return admission;
+}
+
+export function recordSessionBudgetUsage(
+  sessionBudget,
+  event,
+  operation = "provider usage settlement",
+) {
+  if (!isRootUsage(event) || typeof sessionBudget?.recordUsage !== "function") {
+    return null;
+  }
+  const status = sessionBudget.recordUsage({
+    ...(event?.callId ? { callId: event.callId } : {}),
+    provider: event?.provider || null,
+    model: event?.model || null,
+    usage: event?.usage || null,
+  });
+  if (status?.aborted) {
+    throw sessionBudgetAdmissionError(status.reason, operation);
+  }
+  return status;
+}
+
+export function markSessionBudgetUsageUnknown(sessionBudget, event) {
+  if (
+    !isRootUsage(event) ||
+    typeof sessionBudget?.markUsageUnknown !== "function"
+  ) {
+    return null;
+  }
+  return sessionBudget.markUsageUnknown({ callId: event.callId });
+}
+
+export function rejectSessionBudgetUsageUnknown(
+  event,
+  operation = "provider usage settlement",
+) {
+  throw sessionBudgetUsageUnknownError(operation, event?.callId || null);
+}

package/src/lib/session-host-snapshot.js

@@ -27,6 +27,7 @@ import {
   sanitizePersistedMessages,
 } from "./session-message-provenance.js";
 import { createSessionTranscriptStructureProjection } from "./session-transcript-structure.js";
+import { normalizeSessionBudgetRootConfig } from "./session-budget-production-root.js";
 
 export const SESSION_HOST_SNAPSHOT_SCHEMA =
   "chainlesschain.session-host-snapshot/v1";
@@ -123,6 +124,14 @@ function titleFromEvents(events) {
   return title;
 }
 
+function sessionBudgetRootFromEvents(events) {
+  const sessionStart = events.find((event) => event?.type === "session_start");
+  if (!Object.hasOwn(sessionStart?.data || {}, "sessionBudgetRoot")) {
+    return null;
+  }
+  return normalizeSessionBudgetRootConfig(sessionStart.data.sessionBudgetRoot);
+}
+
 function validatePlainSessionEvents(events, sessionId) {
   // Validate the complete nested graph without invoking accessors/Proxy traps,
   // then retain the original in-process objects so an already-established
@@ -292,12 +301,14 @@ export function projectVerifiedSessionHostSnapshot(sessionId, events) {
     }),
     messages,
     recovery,
+    sessionBudgetRoot: sessionBudgetRootFromEvents(safeEvents),
   });
 }
 
 function createStreamingSessionHostProjection(sessionId) {
   let title = "Untitled";
   let lastEventType = null;
+  let sessionBudgetRoot = null;
   const structure = createSessionTranscriptStructureProjection(sessionId, {
     failFast: true,
   });
@@ -313,8 +324,13 @@ function createStreamingSessionHostProjection(sessionId) {
         throw new TypeError("Verified session event must be plain JSON data");
       }
       structure.accept(safeEvent);
-      if (safeEvent.type === "session_start" && safeEvent.data?.title) {
-        title = String(safeEvent.data.title);
+      if (safeEvent.type === "session_start") {
+        if (safeEvent.data?.title) title = String(safeEvent.data.title);
+        if (Object.hasOwn(safeEvent.data || {}, "sessionBudgetRoot")) {
+          sessionBudgetRoot = normalizeSessionBudgetRootConfig(
+            safeEvent.data.sessionBudgetRoot,
+          );
+        }
       } else if (safeEvent.type === "session_rename" && safeEvent.data?.title) {
         title = String(safeEvent.data.title);
       }
@@ -347,6 +363,7 @@ function createStreamingSessionHostProjection(sessionId) {
         }),
         messages,
         recovery,
+        sessionBudgetRoot,
       });
     },
   };