pi-spark 0.14.5 → 0.14.7

package/README.md

@@ -6,6 +6,20 @@
 
 ![Overview](./assets/screenshot-overview.png)
 
+## Install
+
+Install from npm:
+
+```bash
+pi install npm:pi-spark
+```
+
+Install from git:
+
+```bash
+pi install git:github.com/zlliang/pi-spark
+```
+
 ## Features
 
 ### Compact TUI: editor, footer, and fullscreen
@@ -131,18 +145,22 @@ Each preset must set all three fields.
 | --- | --- | --- |
 | `provider` | string | Provider ID, e.g., `anthropic`. |
 | `model` | string | Model ID, e.g., `claude-opus-4-8`. |
-| `thinkingLevel` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh` | Thinking level for the preset. |
+| `thinkingLevel` | `ModelThinkingLevel` | Thinking level for the preset. |
 
 #### `RecapConfig`
 
-All fields are optional, including `thinkingLevel`.
+All fields are optional, including `thinkingLevel`. If the recap model configuration is incomplete, pi-spark falls back to the session's main model.
 
 | Field | Value | Description |
 | --- | --- | --- |
-| `idle` | number (ms) or duration string | How long the session must stay idle before a recap is generated. Accepts a millisecond number or a [vercel/ms](https://github.com/vercel/ms) string (e.g., `"3m"`); minimum 5000 ms, defaults to 3 minutes. |
+| `idle` | number (ms) or duration string | How long the session must stay idle before a recap is generated. Accepts a millisecond number or a [vercel/ms](https://github.com/vercel/ms) string (e.g., `"5m"`); minimum 5000 ms, defaults to 5 minutes. |
 | `provider` | string | Provider ID for the recap model. |
 | `model` | string | Model ID for the recap model. |
-| `thinkingLevel` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh` | Thinking level for the recap model. |
+| `thinkingLevel` | `ModelThinkingLevel` | Thinking level for the recap model. |
+
+#### `ModelThinkingLevel`
+
+Valid values: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`.
 
 ### Turn off the features you don't like
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-spark",
-  "version": "0.14.5",
+  "version": "0.14.7",
   "description": "Pi package that polishes your daily experience and keeps you at the frontier of agentic workflows.",
   "keywords": [
     "pi-coding-agent",

package/src/config/index.ts

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
-import { sparkConfigSchema } from "./schema";
+import { featureSchemas } from "./schema";
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { SparkConfig } from "./schema";
@@ -10,18 +10,6 @@ import type { SparkConfig } from "./schema";
 type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
 type JsonObject = { [key: string]: JsonValue };
 
-/** All features disabled; used as the fallback when `spark.json` fails validation. */
-const DISABLED_CONFIG: SparkConfig = Object.freeze({
-  credits: false,
-  editor: false,
-  footer: false,
-  fullscreen: false,
-  pi: false,
-  presets: false,
-  recap: false,
-  web: false,
-});
-
 const cache = new Map<string, SparkConfig>();
 
 /** Load and validate spark.json once per session lifecycle; later calls return the cached result. */
@@ -30,23 +18,44 @@ export function loadConfig(ctx: ExtensionContext, fileName: string = "spark.json
   const cached = cache.get(key);
   if (cached) return cached;
 
-  const rawConfig = loadMergedJson(getConfigPaths(ctx.cwd, fileName)) ?? {};
-  const result = sparkConfigSchema.safeParse(rawConfig);
+  const rawValue = loadMergedJson(getConfigPaths(ctx.cwd, fileName)) ?? {};
+  const raw = isPlainObject(rawValue) ? rawValue : {};
+
+  // Validate each feature independently so a single invalid field disables only that feature
+  // (falling back to its enabled defaults) instead of taking down the whole config.
+  const config = {} as Record<keyof SparkConfig, unknown>;
+  const errors: string[] = [];
+
+  for (const field of Object.keys(featureSchemas) as (keyof SparkConfig)[]) {
+    const value = raw[field];
+
+    if (value === undefined) {
+      config[field] = {};
+      continue;
+    }
 
-  if (!result.success) {
-    const message = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
-    ctx.ui.notify(`Invalid spark config: ${message}`, "error");
+    if (value === false) {
+      config[field] = false;
+      continue;
+    }
 
-    const config = DISABLED_CONFIG;
-    cache.set(key, config);
+    const result = featureSchemas[field].safeParse(value);
+    if (result.success) {
+      config[field] = result.data;
+      continue;
+    }
 
-    return config;
+    config[field] = {};
+    const detail = result.error.issues.map((issue) => `${[field, ...issue.path].join(".")}: ${issue.message}`).join("; ");
+    errors.push(detail);
   }
 
-  const config = result.data;
-  cache.set(key, config);
+  if (errors.length > 0) {
+    ctx.ui.notify(`Invalid spark config, using defaults for: ${errors.join("; ")}`, "error");
+  }
 
-  return config;
+  cache.set(key, config as SparkConfig);
+  return config as SparkConfig;
 }
 
 function getConfigPaths(cwd: string, fileName: string): [globalPath: string, projectPath: string] {

package/src/config/schema.ts

@@ -9,22 +9,23 @@ import { presetsConfigSchema } from "../features/presets/config";
 import { recapConfigSchema } from "../features/recap/config";
 import { webConfigSchema } from "../features/web/config";
 
-const disabled = z.literal(false);
-
 /**
- * Each feature field is `{ ... } | false`: `false` disables the feature, an object configures
- * it, and an omitted field falls back to defaults (`{}`, enabled).
+ * Raw option shape for each feature. The enable/disable/default policy lives in `loadConfig`:
+ * an omitted field falls back to `{}` (enabled with defaults), `false` disables the feature, and
+ * any other value is validated against the feature schema.
  */
-export const sparkConfigSchema = z.object({
-  credits: creditsConfigSchema.or(disabled).default({}),
-  editor: editorConfigSchema.or(disabled).default({}),
-  footer: footerConfigSchema.or(disabled).default({}),
-  fullscreen: fullscreenConfigSchema.or(disabled).default({}),
-  pi: piConfigSchema.or(disabled).default({}),
-  presets: presetsConfigSchema.or(disabled).default({}),
-  recap: recapConfigSchema.or(disabled).default({}),
-  web: webConfigSchema.or(disabled).default({}),
-});
+export const featureSchemas = {
+  credits: creditsConfigSchema,
+  editor: editorConfigSchema,
+  footer: footerConfigSchema,
+  fullscreen: fullscreenConfigSchema,
+  pi: piConfigSchema,
+  presets: presetsConfigSchema,
+  recap: recapConfigSchema,
+  web: webConfigSchema,
+} as const;
 
 /** Resolved config for every feature; `false` means the feature is disabled. */
-export type SparkConfig = z.infer<typeof sparkConfigSchema>;
+export type SparkConfig = {
+  [K in keyof typeof featureSchemas]: z.infer<(typeof featureSchemas)[K]> | false;
+};

package/src/features/credits/index.ts

@@ -2,8 +2,8 @@ import { CreditsManager } from "./manager";
 import { loadConfig } from "../../config";
 import { isUsage } from "../../utils/usage";
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 function hasCost(message: AgentMessage): boolean {
   const usage = (message as { usage?: unknown }).usage;
@@ -44,6 +44,7 @@ export function registerCredits(pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", () => {
+    creditsManager?.cancel();
     creditsManager = undefined;
   });
 }

package/src/features/credits/manager.ts

@@ -36,25 +36,29 @@ export class CreditsManager {
     });
   }
 
+  cancel(): void {
+    this.inflight?.abort();
+    this.inflight = undefined;
+  }
+
   private async fetch(ctx: ExtensionContext, provider: CreditsProvider, signal: AbortSignal): Promise<void> {
     try {
       const apiKey = await ctx.modelRegistry.getApiKeyForProvider(provider.id);
+      if (signal.aborted) return;
       if (!apiKey) {
         ctx.ui.setStatus(STATUS_KEY, undefined);
         return;
       }
 
-      const signals = [AbortSignal.timeout(REQUEST_TIMEOUT_MS), signal];
-      if (ctx.signal) signals.push(ctx.signal);
-
-      const credits = await provider.fetch(ctx, apiKey, AbortSignal.any(signals));
+      const signals = AbortSignal.any([AbortSignal.timeout(REQUEST_TIMEOUT_MS), signal]);
+      const credits = await provider.fetch(ctx, apiKey, signals);
 
       // The active model may have changed while the request was in flight.
       if (ctx.model?.provider !== provider.id) return;
 
       ctx.ui.setStatus(STATUS_KEY, renderCredits(ctx.ui.theme, provider.label, credits));
     } catch (error) {
-      if (signal.aborted || ctx.signal?.aborted) return;
+      if (signal.aborted) return;
       if (ctx.model?.provider !== provider.id) return;
 
       const message = error instanceof Error ? error.message : String(error);

package/src/features/editor/index.ts

@@ -78,7 +78,7 @@ class Editor extends CustomEditor {
     const modelBeforeText = this.slots.modelBefore;
     const modelText = formatModel(this.ctx.model?.provider, this.ctx.model?.id, this.pi.getThinkingLevel());
 
-    return theme.fg("dim", [modelBeforeText, modelText].filter(Boolean).join(" • "));
+    return theme.fg("dim", [modelBeforeText, modelText].filter(Boolean).join(" · "));
   }
 }
 

package/src/features/footer/index.ts

@@ -39,7 +39,7 @@ class FooterComponent implements Component {
     const branch = this.footerData.getGitBranch();
     const sessionName = this.ctx.sessionManager.getSessionName();
 
-    return this.theme.fg("dim", [cwdText, branch, sessionName].filter(Boolean).join(" • "));
+    return this.theme.fg("dim", [cwdText, branch, sessionName].filter(Boolean).join(" · "));
   }
 
   private getRight(): string {
@@ -47,7 +47,7 @@ class FooterComponent implements Component {
     const styledCostText = this.getStyledCostText();
     const styledContextUsageText = this.getStyledContextUsageText();
 
-    return [statusesText, styledCostText, styledContextUsageText].filter(Boolean).join(this.theme.fg("dim", " • "));
+    return [statusesText, styledCostText, styledContextUsageText].filter(Boolean).join(this.theme.fg("dim", " · "));
   }
 
   /** Get extension statuses, sorted by key alphabetically. */
@@ -58,7 +58,7 @@ class FooterComponent implements Component {
     return Array.from(extensionStatuses.entries())
       .sort(([a], [b]) => a.localeCompare(b))
       .map(([, text]) => sanitizeText(text))
-      .join(this.theme.fg("dim", " • "));
+      .join(this.theme.fg("dim", " · "));
   }
 
   private getStyledCostText(): string {

package/src/features/pi/actions/models.ts

@@ -1,4 +1,4 @@
-import { keyText, truncateHead } from "@earendil-works/pi-coding-agent";
+import { keyHint, truncateHead } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { filter, parse } from "liqe";
 import { Type } from "typebox";
@@ -92,7 +92,7 @@ export const modelsAction = defineAction({
       addRows(models.slice(0, maxRows).map((model) => toModelRow(model)));
 
       const hiddenRows = models.length - maxRows;
-      if (hiddenRows > 0) container.addChild(new Text(theme.fg("dim", `... (${hiddenRows} more, ${keyText("app.tools.expand")} to expand)`), 0, 0));
+      if (hiddenRows > 0) container.addChild(new Text(theme.fg("dim", `... (${hiddenRows} more, `) + keyHint("app.tools.expand", "to expand") + theme.fg("dim", ")"), 0, 0));
       container.addChild(new Spacer(1));
     }
 

package/src/features/pi/actions/name.ts

@@ -22,23 +22,13 @@ export const nameAction = defineAction({
         "(e.g., \"Refactor auth module\", \"Debug flaky CI pipeline\"). Do not use " +
         "surrounding quotes, trailing punctuation, or generic prefixes like \"Chat about\".",
     }),
-    reason: Type.Optional(Type.String({
-      maxLength: 240,
-      description:
-        "For \"name\": Explain briefly why the session was named or renamed, such as a long pasted " +
-        "prompt, an ambiguous first message, or a topic shift. Write one user-facing " +
-        "sentence (e.g., \"The focus shifted from debugging to README updates.\").",
-    })),
   },
   required: ["name"],
   promptGuidelines: [
     "Use the pi tool's \"name\" action to give the current session a concise, recognizable name, especially after a long, vague, or pasted opening prompt, or after a substantial shift in the conversation's focus.",
   ],
   renderParams(args, theme) {
-    const name = theme.fg("muted", sanitizeText(args.name ?? ""));
-    const reason = sanitizeText(args.reason ?? "");
-
-    return [reason ? name + theme.fg("muted", "\n\n" + reason) : name];
+    return [theme.fg("muted", sanitizeText(args.name ?? ""))];
   },
   renderResult() {
     // "name" has no success UI; errors are rendered by the registry's fallback.

package/src/features/pi/actions/whoami.ts

@@ -31,14 +31,16 @@ export const whoamiAction = defineAction({
       return container;
     }
 
+    const formatLine = (label: string, value: string) => `${label.padEnd(7)}  ${value}`;
+
     if (details.sessionName) {
-      container.addChild(new Text(theme.fg("muted", `session  ${details.sessionName}`), 0, 0));
+      container.addChild(new Text(theme.fg("muted", formatLine("session", details.sessionName)), 0, 0));
     }
 
     if (details.model) {
       const row = toModelRow(details.model, details.thinkingLevel);
       const cells = [row.label, row.cost, row.context].join("  ");
-      container.addChild(new Text(theme.fg("muted", `model    ${cells}`), 0, 0));
+      container.addChild(new Text(theme.fg("muted", formatLine("model", cells)), 0, 0));
     }
 
     return container;

package/src/features/presets/index.ts

@@ -14,9 +14,9 @@ export function registerPresets(pi: ExtensionAPI): void {
     type: "string",
   });
 
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("session_start", async (event, ctx) => {
     const config = loadConfig(ctx).presets;
-    const presetFlag = pi.getFlag("preset");
+    const presetFlag = event.reason === "startup" ? pi.getFlag("preset") : undefined;
 
     if (!config || Object.keys(config).length === 0) {
       if (presetFlag) ctx.ui.notify("No presets defined in spark.json", "warning");

package/src/features/presets/selector.ts

@@ -1,5 +1,5 @@
-import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import { Container, SelectList, Spacer, Text } from "@earendil-works/pi-tui";
+import { keyHint, rawKeyHint, DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Box, Container, SelectList, Spacer, Text } from "@earendil-works/pi-tui";
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PresetManager } from "./manager";
@@ -20,12 +20,11 @@ export async function showPresetSelector(ctx: ExtensionContext, presetManager: P
       }));
 
     const container = new Container();
-
     container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-    container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.bold("Select preset"), 0, 0));
-    container.addChild(new Text(theme.fg("dim", "↑↓ navigate · enter select · esc cancel"), 0, 0));
-    container.addChild(new Spacer(1));
+
+    const box = new Box(1, 1);
+    box.addChild(new Text(theme.bold(theme.fg("accent", "Select preset")), 0, 0));
+    box.addChild(new Spacer(1));
 
     const selectList = new SelectList(items, 10, {
       selectedPrefix: (text) => theme.fg("accent", text),
@@ -36,9 +35,17 @@ export async function showPresetSelector(ctx: ExtensionContext, presetManager: P
     });
     selectList.onSelect = (item) => done(item.value);
     selectList.onCancel = () => done(null);
-    container.addChild(selectList);
+    box.addChild(selectList);
+    box.addChild(new Spacer(1));
+
+    const keyHints = [
+      rawKeyHint("↑↓", "navigate"),
+      keyHint("tui.select.confirm", "select"),
+      keyHint("tui.select.cancel", "cancel"),
+    ];
+    box.addChild(new Text(keyHints.join("  "), 0, 0));
 
-    container.addChild(new Spacer(1));
+    container.addChild(box);
     container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
 
     return {

package/src/features/recap/idle.ts

@@ -31,7 +31,7 @@ export const idleTimeoutSchema = z
 type IdleTimeout = z.infer<typeof idleTimeoutSchema>;
 type IdleHash = string | number | boolean;
 
-const DEFAULT_IDLE_MS = 3 * 60 * 1000;
+const DEFAULT_IDLE_MS = 5 * 60 * 1000;
 const POLL_MS = 1_000;
 
 export class IdleListener<T> {

package/src/features/web/render.ts

@@ -1,4 +1,4 @@
-import { keyText } from "@earendil-works/pi-coding-agent";
+import { keyHint } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 
 import { joinTextContent } from "../../utils/format";
@@ -28,7 +28,7 @@ export function renderWebResult(result: AgentToolResult<unknown>, expanded: bool
   container.addChild(new Text(theme.fg("muted", lines.slice(0, maxLines).join("\n")), 0, 0));
 
   const hidden = lines.length - maxLines;
-  if (hidden > 0) container.addChild(new Text(theme.fg("dim", `... (${hidden} more lines, ${keyText("app.tools.expand")} to expand)`), 0, 0));
+  if (hidden > 0) container.addChild(new Text(theme.fg("dim", `... (${hidden} more lines, `) + keyHint("app.tools.expand", "to expand") + theme.fg("dim", ")"), 0, 0));
 
   return container;
 }

package/src/utils/tool.ts

@@ -4,7 +4,7 @@ import { Type } from "typebox";
 
 import { formatDuration, joinTextContent } from "./format";
 
-import type { AgentToolResult, ExtensionAPI, ExtensionContext, Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AgentToolResult, AgentToolUpdateCallback, ExtensionAPI, ExtensionContext, Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 import type { Static, TObject, TProperties, TSchema } from "typebox";
 
@@ -28,8 +28,9 @@ export interface Action<C, F extends TProperties = TProperties, D extends Action
   showTiming?: boolean;
   /** Styled segments shown after the `<tool> <action>` prefix. */
   renderParams?: (args: Static<TObject<F>>, theme: Theme) => string[];
+  /** Only handles successful output; error output is handled centrally. */
   renderResult?: NonNullable<ToolDefinition<TObject<F>, D>["renderResult"]>;
-  execute(args: Static<TObject<F>>, context: C, signal: AbortSignal | undefined): Promise<AgentToolResult<D>>;
+  execute(args: Static<TObject<F>>, context: C, signal: AbortSignal | undefined, onUpdate: AgentToolUpdateCallback<D> | undefined): Promise<AgentToolResult<D>>;
 }
 
 /** Identity helper bound to context `C`, so actions infer their field/details types while sharing one context shape. */
@@ -75,7 +76,6 @@ export function registerComposedTool<C>(pi: ExtensionAPI, config: ComposedToolCo
 
   const activeTiming = new ActiveTiming();
   const noTiming = new NoTiming();
-  // Resolve per-action timing from the stable call args, so error results (no details) still settle.
   const timingFor = (action: string | undefined): Timing => (byName.get(action ?? "")?.showTiming ? activeTiming : noTiming);
 
   const renderActionResult: NonNullable<ToolDefinition["renderResult"]> = (result, options, theme, context) => {
@@ -111,7 +111,7 @@ export function registerComposedTool<C>(pi: ExtensionAPI, config: ComposedToolCo
 
       return timingFor(context.args.action).renderResult(inner, options, theme, context);
     },
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const action = byName.get(params.action);
       if (!action) throw new Error(`Unknown ${config.name} action "${params.action}"`);
 
@@ -121,7 +121,7 @@ export function registerComposedTool<C>(pi: ExtensionAPI, config: ComposedToolCo
         }
       }
 
-      return action.execute(params as never, config.createContext(ctx), signal);
+      return action.execute(params as any, config.createContext(ctx), signal, onUpdate);
     },
   });
 }
@@ -147,55 +147,67 @@ interface TimingState {
   startedAt?: number;
   endedAt?: number;
   interval?: ReturnType<typeof setInterval>;
+  hasResult?: boolean;
 }
 
 class ActiveTiming implements Timing {
+  // No result yet: `renderCall` owns the live "Elapsed" ticker.
   renderCall(inner: Component, ...[theme, context]: RenderCallTail): Component {
     const state = context.state as TimingState;
+
     if (context.executionStarted && state.startedAt === undefined) {
       state.startedAt = Date.now();
       delete state.endedAt;
+      delete state.hasResult;
     }
 
-    // Result is in: renderResult owns the timing line, so just settle here.
-    if (!context.isPartial) {
-      this.settle(state);
-      return inner;
-    }
-
-    // Still running, no result yet: show a live "Elapsed" line, ticking once a second.
-    if (state.startedAt === undefined) return inner;
+    // Not started, or final (`renderResult` owns the "Took" line): render nothing here.
+    if (state.startedAt === undefined || !context.isPartial) return inner;
 
     state.interval ??= setInterval(() => context.invalidate(), 1000);
-    return this.withTimingLine(inner, "Elapsed", Date.now() - state.startedAt, theme);
+
+    // `renderResult` runs later in the same render pass, so decide visibility at render time:
+    // hide once any result has arrived.
+    return this.withTimingLine(inner, "Elapsed", Date.now() - state.startedAt, theme, () => !state.hasResult);
   }
 
+  // A result exists: `renderResult` owns the line — "Elapsed" while streaming, "Took" once final.
   renderResult(inner: Component, ...[options, theme, context]: RenderResultTail): Component {
     const state = context.state as TimingState;
-    if (!options.isPartial || context.isError) this.settle(state);
+    state.hasResult = true;
+
+    const isRunning = options.isPartial && !context.isError;
+    if (!isRunning) this.settle(state);
     if (state.startedAt === undefined) return inner;
 
-    const label = options.isPartial ? "Elapsed" : "Took";
     const endTime = state.endedAt ?? Date.now();
-    return this.withTimingLine(inner, label, endTime - state.startedAt, theme);
+    return this.withTimingLine(inner, isRunning ? "Elapsed" : "Took", endTime - state.startedAt, theme);
   }
 
   private settle(state: TimingState): void {
-    if (state.startedAt !== undefined) state.endedAt ??= Date.now();
+    if (state.startedAt !== undefined) {
+      state.endedAt ??= Date.now();
+    }
+
     if (state.interval) {
       clearInterval(state.interval);
       delete state.interval;
     }
   }
 
-  private withTimingLine(content: Component, label: string, ms: number, theme: Theme): Container {
+  private withTimingLine(content: Component, label: string, ms: number, theme: Theme, visible?: () => boolean): Component {
     const container = new Container();
     container.addChild(content);
 
     container.addChild(new Spacer(1));
-    container.addChild(new Text(`${theme.fg("muted", `${label} ${formatDuration(ms)}`)}`, 0, 0));
+    container.addChild(new Text(theme.fg("muted", `${label} ${formatDuration(ms)}`), 0, 0));
+
+    if (!visible) return container;
 
-    return container;
+    return {
+      invalidate: () => container.invalidate(),
+      render: (width) => (visible() ? container.render(width) : content.render(width)),
+    };
   }
 }