okengine 0.13.0 → 0.14.1

package/src/drivers/ai-ollama.ts

@@ -156,10 +156,7 @@ export async function openOllama(options: AiOpenOptions = {}): Promise<AiModelCl
         const msg = raw.error ?? `ollama HTTP ${res.status}`;
         throw new OllamaUnavailableError(`ollama: ${msg}`);
       }
-      if (!res.body) {
-        throw new OllamaUnavailableError("ollama: stream response has no body");
-      }
-      yield* readOllamaNdjson(res.body, opts.signal);
+      yield* readOllamaNdjson(res, opts.signal);
     },
     async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
       const resolvedModel = resolveOllamaModel(options, opts.model);
@@ -265,45 +262,45 @@ function parseOllamaToolCalls(
 }
 
 /**
- * Parse Ollama NDJSON stream lines.
+ * Parse Ollama NDJSON stream lines via {@link Bun.JSONL.parseChunk}.
  *
- * @param body - Response body
+ * @param res - Streaming response
  * @param signal - Optional abort
  */
 async function* readOllamaNdjson(
-  body: ReadableStream<Uint8Array>,
+  res: Response,
   signal?: AbortSignal,
 ): AsyncGenerator<AiStreamChunk> {
-  const reader = body.getReader();
+  const reader = res.body?.getReader();
+  if (!reader) {
+    throw new OllamaUnavailableError("ollama: stream response has no body");
+  }
   const decoder = new TextDecoder();
-  let buffer = "";
+  let pending = "";
   try {
     while (true) {
-      if (signal?.aborted) {
-        throw abortAsError(signal.reason);
-      }
+      if (signal?.aborted) throw abortAsError(signal.reason);
       const { done, value } = await reader.read();
       if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const chunk = JSON.parse(trimmed) as OllamaChatResponse;
-          const delta = chunk.message?.content;
-          if (typeof delta === "string" && delta.length > 0) {
-            yield { text: delta };
-          }
-          if (chunk.done) {
-            yield { text: "", done: true };
-            return;
-          }
-        } catch {
-          // ignore malformed lines
+      pending += decoder.decode(value, { stream: true });
+      const parsed = bunJsonl().parseChunk(pending);
+      pending = pending.slice(parsed.read);
+      for (const row of parsed.values) {
+        const chunk = row as OllamaChatResponse;
+        const delta = chunk.message?.content;
+        if (typeof delta === "string" && delta.length > 0) {
+          yield { text: delta };
+        }
+        if (chunk.done) {
+          yield { text: "", done: true };
+          return;
         }
       }
+      if (parsed.error) {
+        const nl = pending.indexOf("\n");
+        if (nl === -1) continue;
+        pending = pending.slice(nl + 1);
+      }
     }
     yield { text: "", done: true };
   } finally {
@@ -311,6 +308,28 @@ async function* readOllamaNdjson(
   }
 }
 
+interface BunJsonlParse {
+  readonly values: readonly unknown[];
+  readonly read: number;
+  readonly done: boolean;
+  readonly error: unknown;
+}
+
+function bunJsonl(): {
+  parse(text: string): unknown[];
+  parseChunk(text: string): BunJsonlParse;
+} {
+  const jsonl = (
+    Bun as typeof Bun & {
+      JSONL?: { parse: (t: string) => unknown[]; parseChunk: (t: string) => BunJsonlParse };
+    }
+  ).JSONL;
+  if (!jsonl) {
+    throw new Error("ollama: Bun.JSONL is required (Bun >= 1.4.0)");
+  }
+  return jsonl;
+}
+
 /**
  * Probe Ollama — fail loud before the first completion.
  *

package/src/drivers/ai-openai-compatible.ts

@@ -89,6 +89,7 @@ export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise
   const model = options.model ?? "gpt-4o-mini";
   const fetchFn = options.fetch ?? globalThis.fetch;
   const extraHeaders = options.headers;
+  preconnectFetch(fetchFn, baseUrl);
 
   return {
     driverId: "openai-compatible",
@@ -162,10 +163,7 @@ export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise
         const msg = raw.error?.message ?? `openai-compatible HTTP ${res.status}`;
         throwHttp(`openai-compatible: ${msg}`, res.status);
       }
-      if (!res.body) {
-        throw new Error("openai-compatible: stream response has no body");
-      }
-      yield* readOpenaiSse(res.body, opts.signal);
+      yield* readOpenaiSse(res, opts.signal);
     },
     async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
       const resolvedModel = opts.model ?? model;
@@ -262,57 +260,70 @@ function parseToolCalls(
 /**
  * Parse OpenAI SSE chat.completion.chunk stream.
  *
- * @param body - Response body
+ * @param res - Streaming response
  * @param signal - Optional abort
  */
-async function* readOpenaiSse(
-  body: ReadableStream<Uint8Array>,
-  signal?: AbortSignal,
-): AsyncGenerator<AiStreamChunk> {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
+async function* readOpenaiSse(res: Response, signal?: AbortSignal): AsyncGenerator<AiStreamChunk> {
   let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) {
-        throw abortAsError(signal.reason);
+  for await (const piece of responseTextStream(res)) {
+    if (signal?.aborted) throw abortAsError(signal.reason);
+    buffer += piece;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:")) continue;
+      const data = trimmed.slice(5).trim();
+      if (data === "[DONE]") {
+        yield { text: "", done: true };
+        return;
       }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:")) continue;
-        const data = trimmed.slice(5).trim();
-        if (data === "[DONE]") {
+      try {
+        const chunk = JSON.parse(data) as {
+          choices?: readonly {
+            delta?: { content?: string | null };
+            finish_reason?: string | null;
+          }[];
+        };
+        const delta = chunk.choices?.[0]?.delta?.content;
+        if (typeof delta === "string" && delta.length > 0) {
+          yield { text: delta };
+        }
+        if (chunk.choices?.[0]?.finish_reason) {
           yield { text: "", done: true };
           return;
         }
-        try {
-          const chunk = JSON.parse(data) as {
-            choices?: readonly {
-              delta?: { content?: string | null };
-              finish_reason?: string | null;
-            }[];
-          };
-          const delta = chunk.choices?.[0]?.delta?.content;
-          if (typeof delta === "string" && delta.length > 0) {
-            yield { text: delta };
-          }
-          if (chunk.choices?.[0]?.finish_reason) {
-            yield { text: "", done: true };
-            return;
-          }
-        } catch {
-          // ignore malformed SSE lines
-        }
+      } catch {
+        // ignore malformed SSE lines
       }
     }
-    yield { text: "", done: true };
-  } finally {
-    reader.releaseLock();
+  }
+  yield { text: "", done: true };
+}
+
+/**
+ * UTF-8 text chunks from a Response (`textStream` on Bun ≥1.4).
+ *
+ * @param res - HTTP response
+ */
+function responseTextStream(res: Response): AsyncIterable<string> {
+  const stream = (res as Response & { textStream?: () => AsyncIterable<string> }).textStream;
+  if (typeof stream !== "function") {
+    throw new Error("openai-compatible: Response.textStream is required (Bun >= 1.4.0)");
+  }
+  return stream.call(res);
+}
+
+/**
+ * Warm DNS+TCP+TLS for a cloud origin. No-op when `fetch` is a test stub.
+ *
+ * @param fetchFn - Fetch implementation
+ * @param url - Provider base URL
+ */
+function preconnectFetch(fetchFn: typeof fetch, url: string): void {
+  const preconnect = (fetchFn as { preconnect?: (href: string) => void }).preconnect;
+  if (typeof preconnect === "function") {
+    preconnect(url);
   }
 }
 

package/src/drivers/ai-providers.test.ts

@@ -43,12 +43,14 @@ describe("anthropic driver", () => {
       model: "claude-test",
       fetch: fetchFn,
     });
+    const ac = new AbortController();
     const result = await client.complete({
       messages: [
         { role: "system", content: "be brief" },
         { role: "user", content: "hi" },
       ],
       maxTokens: 64,
+      signal: ac.signal,
     });
 
     expect(result.driverId).toBe("anthropic");
@@ -62,6 +64,7 @@ describe("anthropic driver", () => {
     };
     expect(body.system).toBe("be brief");
     expect(body.messages).toEqual([{ role: "user", content: "hi" } as { role: string }]);
+    expect(calls[0]!.init?.signal).toBe(ac.signal);
   });
 
   test("HTTP error surfaces provider message", async () => {

package/src/drivers/bun-native-completeness.test.ts

@@ -1,8 +1,8 @@
 /**
  * Bun native-client completeness — gaps closed vs platform limitations.
  *
- * Checked against Bun 1.3.14 (runtime + bun-types). Do not invent custom
- * protocol clients where Bun still lacks an API.
+ * Checked against Bun 1.4 (runtime). Do not invent custom protocol clients
+ * where Bun still lacks an API.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -46,7 +46,7 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
       status: hasTypedEval ? "closed" : "bun_limitation",
       note: hasTypedEval
         ? "typed eval bound"
-        : "Bun 1.3.14 has no typed eval — driver uses send(EVAL)",
+        : "Bun.RedisClient.eval unavailable — would keep send(EVAL)",
     },
     {
       surface: "redis signal",
@@ -63,7 +63,7 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
       status: hasTypedXadd ? "closed" : "bun_limitation",
       note: hasTypedXadd
         ? "typed stream helpers bound"
-        : "Bun 1.3.14 has no typed xadd — Streams use send (native, not a custom client)",
+        : "Bun.RedisClient.xadd unavailable — Streams would keep send",
     },
     {
       surface: "redis signal",
@@ -95,23 +95,21 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
 }
 
 describe("Bun native client completeness", () => {
-  test("report table is exact and matches runtime Bun 1.3.x", () => {
+  test("report table is exact and matches runtime Bun 1.4", () => {
     const rows = bunNativeCompletenessReport();
     expect(rows.length).toBe(8);
 
     const closed = rows.filter((r) => r.status === "closed").map((r) => r.capability);
     const limited = rows.filter((r) => r.status === "bun_limitation").map((r) => r.capability);
 
-    // Closed on Bun 1.3.14
     expect(closed).toContain("SCAN (typed)");
+    expect(closed).toContain("EVAL (typed)");
     expect(closed).toContain("native Bun bind (publish/subscribe)");
+    expect(closed).toContain("XADD / XREADGROUP (typed)");
     expect(closed).toContain("send escape hatch");
     expect(closed).toContain("Bun.SQL.unsafe query/exec");
     expect(closed).toContain("Bun.S3Client file/list");
 
-    // Genuine Bun platform limitations (do not invent workarounds)
-    expect(limited).toContain("EVAL (typed)");
-    expect(limited).toContain("XADD / XREADGROUP (typed)");
     expect(limited).toContain("LISTEN / NOTIFY on Bun.SQL");
   });
 

package/src/drivers/redis.ts

@@ -140,11 +140,19 @@ function ttlToSeconds(ttl: string): number {
   }
 }
 
+/** Bun 1.4 typed methods — `@types/bun` may lag the runtime. */
+interface BunRedisEval {
+  eval(script: string, numkeys: number, ...keysAndArgs: string[]): Promise<unknown>;
+}
+
+function typedRedis(redis: Bun.RedisClient): Bun.RedisClient & BunRedisEval {
+  return redis as Bun.RedisClient & BunRedisEval;
+}
+
 /**
  * Bind {@link Bun.RedisClient} / {@link Bun.redis} to {@link KvClientLike}.
  *
- * Uses typed `scan` (Bun ≥1.3). `EVAL` still goes through `send` — Bun 1.3.14
- * has no typed `eval` yet (platform limitation, not an OKE stub).
+ * Uses typed `scan` / `eval` (Bun ≥1.4). `send` remains the escape hatch.
  *
  * @param url - Optional Redis URL
  */
@@ -174,8 +182,7 @@ export function createBunRedisClient(url?: string): KvClientLike {
       return redis.scan(cursor);
     },
     async eval(script, numkeys, ...keysAndArgs) {
-      // Bun 1.3.14: no typed eval — raw send remains the native path.
-      return redis.send("EVAL", [script, String(numkeys), ...keysAndArgs]);
+      return typedRedis(redis).eval(script, numkeys, ...keysAndArgs);
     },
     send: (command, args) => redis.send(command, args),
   };

package/src/drivers/signal-redis.ts

@@ -7,7 +7,7 @@
  * exactly-once / fan-out physics stay correct under `drain()`.
  *
  * Production bind: {@link createBunSignalRedisClient} (typed `publish` /
- * `subscribe`; Streams via `send` — Bun 1.3.14 has no typed `xadd` yet).
+ * `subscribe` / `xadd` / `xreadgroup` / `xack` / `xgroup` on Bun ≥1.4).
  */
 
 import { createSignalEngine } from "./signal-engine.ts";
@@ -18,12 +18,23 @@ import type {
   SignalRedisClientLike,
 } from "./signal-types.ts";
 
+/** Bun 1.4 typed stream methods — `@types/bun` may lag the runtime. */
+interface BunRedisStreams {
+  xadd(key: string, ...args: (string | number)[]): Promise<unknown>;
+  xreadgroup(...args: (string | number)[]): Promise<unknown>;
+  xack(key: string, group: string, id: string): Promise<unknown>;
+  xgroup(subcommand: string, ...args: (string | number)[]): Promise<unknown>;
+}
+
+function typedStreams(redis: Bun.RedisClient): Bun.RedisClient & BunRedisStreams {
+  return redis as Bun.RedisClient & BunRedisStreams;
+}
+
 /**
  * Bind {@link Bun.RedisClient} to {@link SignalRedisClientLike}.
  *
- * Streams (`XADD` / `XGROUP` / `XREADGROUP` / `XACK`) use `send` because
- * Bun 1.3.14 still lacks typed stream helpers — that is a Bun limitation.
- * Pub/sub uses typed `publish` / `subscribe` (gap closed vs earlier fake-only).
+ * Streams use typed `xadd` / `xgroup` / `xreadgroup` / `xack` (Bun ≥1.4).
+ * Pub/sub uses typed `publish` / `subscribe`.
  *
  * @param url - Optional Redis URL
  */
@@ -41,37 +52,36 @@ export function createBunSignalRedisClient(url?: string): SignalRedisClientLike
 
   return {
     async xadd(key, id, fields) {
-      const args: string[] = [key, id];
+      const pairs: string[] = [];
       for (const [k, v] of Object.entries(fields)) {
-        args.push(k, v);
+        pairs.push(k, v);
       }
-      return String(await redis.send("XADD", args));
+      return String(await typedStreams(redis).xadd(key, id, ...pairs));
     },
     async xgroupCreate(key, group, id, opts) {
-      const args = ["CREATE", key, group, id];
-      if (opts?.mkstream) args.push("MKSTREAM");
+      const extra = opts?.mkstream ? (["MKSTREAM"] as const) : [];
       try {
-        await redis.send("XGROUP", args);
+        await typedStreams(redis).xgroup("CREATE", key, group, id, ...extra);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         if (!/BUSYGROUP/i.test(msg)) throw err;
       }
     },
     async xreadgroup(group, consumer, key, count) {
-      const reply = await redis.send("XREADGROUP", [
+      const reply = await typedStreams(redis).xreadgroup(
         "GROUP",
         group,
         consumer,
         "COUNT",
-        String(count),
+        count,
         "STREAMS",
         key,
         ">",
-      ]);
+      );
       return parseXreadgroupReply(reply);
     },
     async xack(key, group, id) {
-      return Number(await redis.send("XACK", [key, group, id]));
+      return Number(await typedStreams(redis).xack(key, group, id));
     },
     async publish(channel, message) {
       return redis.publish(channel, message);

package/src/drivers/signal-types.ts

@@ -69,8 +69,9 @@ export interface SignalMessage {
 }
 
 /** Dead-letter entry with full attempt history. */
-export interface DeadLetter extends SignalMessage {
+export interface DeadLetter<T = unknown> extends Omit<SignalMessage, "payload" | "status"> {
   readonly status: "dead";
+  readonly payload: T;
 }
 
 /** Per-subscriber lag / errors (broadcast physics). */

package/src/elements/ai/declare.ts

@@ -7,9 +7,12 @@
 import {
   aiAgentRegistry,
   aiEmbedRegistry,
+  aiMcpServerRegistry,
   aiModelRegistry,
   aiPromptRegistry,
 } from "../../kernel/element-registries.ts";
+import { mcpToolRef, type McpToolRef } from "../../manifest/mcp-ref.ts";
+import type { VaultSecretDecl } from "../vault/declare.ts";
 
 /** Budget for a prompt or agent. */
 export interface AiBudgetDecl {
@@ -30,6 +33,11 @@ export interface AiModelOptions {
   readonly baseUrl?: string;
   /** Optional API key override for this binding (cloud providers). */
   readonly apiKey?: string;
+  /**
+   * Protocol driver for this binding (`anthropic`, `ollama`, …).
+   * When omitted, the app-level default driver is used.
+   */
+  readonly driverId?: string;
 }
 
 /**
@@ -77,6 +85,7 @@ export interface AiModelDecl {
   readonly model?: string;
   readonly baseUrl?: string;
   readonly apiKey?: string;
+  readonly driverId?: string;
   /**
    * Declare a versioned prompt artifact on this model.
    *
@@ -118,6 +127,54 @@ export interface AiAgentDecl {
   readonly budget?: AiBudgetDecl;
 }
 
+/** Bearer auth for {@link ai.mcpServer} — secret contract, never a token literal. */
+export interface AiMcpServerAuthOptions {
+  readonly bearer: VaultSecretDecl | string;
+}
+
+/** Options for {@link ai.mcpServer}. */
+export interface AiMcpServerOptions {
+  /** Streamable HTTP endpoint. */
+  readonly url?: string;
+  /** stdio executable (no shell string). */
+  readonly command?: string;
+  /** Arguments for {@link command}. */
+  readonly args?: readonly string[];
+  /** Bearer secret contract (`vault.secret` handle or name). */
+  readonly auth?: AiMcpServerAuthOptions;
+  /**
+   * Required allowlist of tool names on this server.
+   * The runtime never offers whatever `tools/list` happens to expose.
+   */
+  readonly tools: readonly string[];
+}
+
+/** Named capability ref returned by {@link AiMcpServerDecl.tool}. */
+export interface AiMcpToolRef {
+  readonly name: McpToolRef;
+}
+
+/**
+ * Declared external MCP server — tools join `fx.call` / `toolLoop` as
+ * `mcp:<server>/<tool>`.
+ */
+export interface AiMcpServerDecl {
+  readonly kind: "mcp-server";
+  readonly name: string;
+  readonly url?: string;
+  readonly command?: string;
+  readonly args?: readonly string[];
+  /** Secret contract name when bearer auth is declared. */
+  readonly auth?: string;
+  readonly tools: readonly string[];
+  /**
+   * Capability ref for one allowlisted tool (`mcp:<server>/<tool>`).
+   *
+   * @param tool - Tool name on this server
+   */
+  tool(tool: string): AiMcpToolRef;
+}
+
 /**
  * Resolve a tool ref to a flow name.
  *
@@ -152,6 +209,13 @@ export interface AiNamespace {
    * @param options - Tools / maxSteps / model / budget
    */
   agent(name: string, options?: AiAgentOptions): AiAgentDecl;
+  /**
+   * Declare an external MCP server whose allowlisted tools join `fx.call`.
+   *
+   * @param name - Server id (`github`, `linear`, …)
+   * @param options - Transport + required tool allowlist
+   */
+  mcpServer(name: string, options: AiMcpServerOptions): AiMcpServerDecl;
 }
 
 /**
@@ -162,12 +226,14 @@ export function listAiDecls(): {
   readonly prompts: readonly AiPromptDecl[];
   readonly embeds: readonly AiEmbedDecl[];
   readonly agents: readonly AiAgentDecl[];
+  readonly mcpServers: readonly AiMcpServerDecl[];
 } {
   return {
     models: aiModelRegistry.slice(),
     prompts: aiPromptRegistry.slice(),
     embeds: aiEmbedRegistry.slice(),
     agents: aiAgentRegistry.slice(),
+    mcpServers: aiMcpServerRegistry.slice(),
   };
 }
 
@@ -179,6 +245,7 @@ export function resetAiDecls(): void {
   aiPromptRegistry.length = 0;
   aiEmbedRegistry.length = 0;
   aiAgentRegistry.length = 0;
+  aiMcpServerRegistry.length = 0;
 }
 
 /**
@@ -201,6 +268,7 @@ export const ai: AiNamespace = {
       ...(options.model !== undefined ? { model: options.model } : {}),
       ...(options.baseUrl !== undefined ? { baseUrl: options.baseUrl } : {}),
       ...(options.apiKey !== undefined ? { apiKey: options.apiKey } : {}),
+      ...(options.driverId !== undefined ? { driverId: options.driverId } : {}),
       prompt(promptName, promptOpts = {}) {
         const promptDecl: AiPromptDecl = {
           kind: "prompt",
@@ -263,4 +331,45 @@ export const ai: AiNamespace = {
     aiAgentRegistry.push(decl);
     return decl;
   },
+
+  /**
+   * Declare an external MCP server whose allowlisted tools join `fx.call`.
+   *
+   * @param name - Server id
+   * @param options - Transport + required tool allowlist
+   */
+  mcpServer(name: string, options: AiMcpServerOptions): AiMcpServerDecl {
+    if (!name) throw new TypeError("ai.mcpServer: name is required");
+    if (name.includes("/") || name.includes("__")) {
+      throw new TypeError(`ai.mcpServer: name "${name}" must not contain "/" or "__"`);
+    }
+    if (!options.tools || !Array.isArray(options.tools)) {
+      throw new TypeError("ai.mcpServer: tools allowlist is required");
+    }
+    const hasUrl = typeof options.url === "string" && options.url.length > 0;
+    const hasCommand = typeof options.command === "string" && options.command.length > 0;
+    if (hasUrl === hasCommand) {
+      throw new TypeError("ai.mcpServer: declare exactly one of url or command");
+    }
+    const allow = new Set(options.tools);
+    const authName =
+      typeof options.auth?.bearer === "string" ? options.auth.bearer : options.auth?.bearer?.name;
+    const decl: AiMcpServerDecl = {
+      kind: "mcp-server",
+      name,
+      ...(hasUrl ? { url: options.url } : {}),
+      ...(hasCommand ? { command: options.command } : {}),
+      ...(options.args !== undefined ? { args: options.args } : {}),
+      ...(authName !== undefined ? { auth: authName } : {}),
+      tools: options.tools,
+      tool(tool: string): AiMcpToolRef {
+        if (!allow.has(tool)) {
+          throw new TypeError(`ai.mcpServer("${name}"): tool "${tool}" is not in the allowlist`);
+        }
+        return { name: mcpToolRef(name, tool) };
+      },
+    };
+    aiMcpServerRegistry.push(decl);
+    return decl;
+  },
 };

package/src/elements/ai/errors.test.ts

@@ -22,7 +22,11 @@ describe("isRetryableAiError", () => {
     expect(isRetryableAiError(new Error("openai-compatible HTTP 401"))).toBe(false);
     const abort = new Error("aborted");
     abort.name = "AbortError";
-    expect(isRetryableAiError(abort)).toBe(true);
+    expect(isRetryableAiError(abort)).toBe(false);
+    const timeout = new Error("deadline");
+    timeout.name = "TimeoutError";
+    expect(isRetryableAiError(timeout)).toBe(true);
+    expect(isRetryableAiError(new Error("request timeout"))).toBe(true);
   });
 });