@ai-sdk/sandbox-vercel 0.0.0 → 1.0.0-beta.15

package/src/vercel-network-sandbox-session.ts

@@ -0,0 +1,132 @@
+import {
+  HarnessCapabilityUnsupportedError,
+  type HarnessV1NetworkPolicy,
+  type HarnessV1NetworkSandboxSession,
+} from '@ai-sdk/harness';
+import type { Experimental_SandboxSession as SandboxSession } from '@ai-sdk/provider-utils';
+import type { Sandbox, NetworkPolicy } from '@vercel/sandbox';
+import { VercelSandboxSession } from './vercel-sandbox-session';
+
+const VERCEL_PROVIDER_ID = 'vercel-sandbox';
+
+/**
+ * `HarnessV1NetworkSandboxSession` backed by a `@vercel/sandbox` `Sandbox`. The
+ * provider's `create()` returns one of these. It extends
+ * {@link VercelSandboxSession} with the infra surface (ports, lifecycle,
+ * network policy). It owns the sandbox's lifecycle only when the provider
+ * created it; when the provider was given an existing sandbox, `stop()` and
+ * `destroy()` are no-ops (caller retains ownership).
+ */
+export class VercelNetworkSandboxSession
+  extends VercelSandboxSession
+  implements HarnessV1NetworkSandboxSession
+{
+  readonly id: string;
+  readonly defaultWorkingDirectory: string;
+  private readonly ownsLifecycle: boolean;
+
+  constructor(input: { sandbox: Sandbox; ownsLifecycle: boolean }) {
+    super(input.sandbox);
+    this.ownsLifecycle = input.ownsLifecycle;
+    this.id = input.sandbox.name;
+    this.defaultWorkingDirectory = input.sandbox.currentSession().cwd;
+  }
+
+  get ports(): ReadonlyArray<number> {
+    return this.sandbox.routes.map(route => route.port);
+  }
+
+  restricted(): SandboxSession {
+    return new VercelSandboxSession(this.sandbox);
+  }
+
+  getPortUrl = async (options: {
+    port: number;
+    protocol?: 'http' | 'https' | 'ws';
+  }): Promise<string> => {
+    const exposedPorts = this.ports;
+    if (!exposedPorts.includes(options.port)) {
+      throw new HarnessCapabilityUnsupportedError({
+        harnessId: VERCEL_PROVIDER_ID,
+        message: `Port ${options.port} is not exposed on this sandbox. Exposed ports: [${exposedPorts.join(', ')}].`,
+      });
+    }
+    const protocol = options.protocol ?? 'https';
+    const url = new URL(this.sandbox.domain(options.port));
+    const isSecure = url.protocol === 'https:';
+    switch (protocol) {
+      case 'http':
+        url.protocol = isSecure ? 'https:' : 'http:';
+        break;
+      case 'https':
+        url.protocol = 'https:';
+        break;
+      case 'ws':
+        url.protocol = isSecure ? 'wss:' : 'ws:';
+        break;
+    }
+    return url.toString();
+  };
+
+  setNetworkPolicy = async (policy: HarnessV1NetworkPolicy): Promise<void> => {
+    await this.sandbox.update({ networkPolicy: toVercelPolicy(policy) });
+  };
+
+  setPorts = async (
+    ports: ReadonlyArray<number>,
+    options?: { abortSignal?: AbortSignal },
+  ): Promise<void> => {
+    await this.sandbox.update(
+      { ports: [...ports] },
+      options?.abortSignal ? { signal: options.abortSignal } : undefined,
+    );
+  };
+
+  stop = async (): Promise<void> => {
+    if (!this.ownsLifecycle) return;
+    await this.sandbox.stop();
+  };
+
+  destroy = async (): Promise<void> => {
+    if (!this.ownsLifecycle) return;
+    await this.sandbox.stop().catch(() => {});
+    await this.sandbox.delete();
+  };
+}
+
+export function toVercelPolicy(policy: HarnessV1NetworkPolicy): NetworkPolicy {
+  switch (policy.mode) {
+    case 'allow-all':
+      return 'allow-all';
+    case 'deny-all':
+      return 'deny-all';
+    case 'custom': {
+      const result: Extract<NetworkPolicy, { allow?: unknown }> = {};
+      const { allowedHosts, allowedCIDRs, deniedCIDRs } = policy;
+      if (allowedHosts != null && allowedHosts.length > 0) {
+        result.allow = [...allowedHosts];
+      }
+      if (
+        (allowedCIDRs != null && allowedCIDRs.length > 0) ||
+        (deniedCIDRs != null && deniedCIDRs.length > 0)
+      ) {
+        result.subnets = {
+          ...(allowedCIDRs != null && allowedCIDRs.length > 0
+            ? { allow: [...allowedCIDRs] }
+            : {}),
+          ...(deniedCIDRs != null && deniedCIDRs.length > 0
+            ? { deny: [...deniedCIDRs] }
+            : {}),
+        };
+      }
+      if (result.allow == null && result.subnets == null) {
+        throw new HarnessCapabilityUnsupportedError({
+          harnessId: VERCEL_PROVIDER_ID,
+          message:
+            'Custom network policy requires at least one of allowedHosts or allowedCIDRs to be non-empty.',
+        });
+      }
+      return result;
+    }
+  }
+}

package/src/vercel-sandbox-session.ts

@@ -0,0 +1,299 @@
+import { posix } from 'node:path';
+import {
+  extractLines,
+  type Experimental_SandboxSession,
+  type Experimental_SandboxProcess,
+} from '@ai-sdk/provider-utils';
+import type { Sandbox, Command } from '@vercel/sandbox';
+
+/**
+ * `Experimental_SandboxSession` implementation backed by a `@vercel/sandbox`
+ * `Sandbox` instance. This is the tool-safe surface (file I/O, exec, spawn);
+ * it is what `VercelNetworkSandboxSession.restricted()` returns and is not
+ * constructed directly by consumers. The network sandbox session owns the
+ * lifetime of the underlying sandbox.
+ */
+export class VercelSandboxSession implements Experimental_SandboxSession {
+  constructor(protected readonly sandbox: Sandbox) {}
+
+  get description(): string {
+    return [
+      `Vercel Sandbox (name: ${this.sandbox.name}).`,
+      'Filesystem changes persist for the lifetime of the sandbox.',
+    ].join('\n');
+  }
+
+  async run({
+    command,
+    workingDirectory,
+    env,
+    abortSignal,
+  }: {
+    command: string;
+    workingDirectory?: string;
+    env?: Record<string, string>;
+    abortSignal?: AbortSignal;
+  }): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+    abortSignal?.throwIfAborted();
+
+    const finished = await this.sandbox.runCommand({
+      cmd: 'bash',
+      args: ['-c', command],
+      ...(workingDirectory !== undefined ? { cwd: workingDirectory } : {}),
+      ...(env !== undefined ? { env } : {}),
+      ...(abortSignal !== undefined ? { signal: abortSignal } : {}),
+    });
+
+    const [stdout, stderr] = await Promise.all([
+      finished.stdout(),
+      finished.stderr(),
+    ]);
+
+    return {
+      exitCode: finished.exitCode,
+      stdout,
+      stderr,
+    };
+  }
+
+  async spawn({
+    command,
+    workingDirectory,
+    env,
+    abortSignal,
+  }: {
+    command: string;
+    workingDirectory?: string;
+    env?: Record<string, string>;
+    abortSignal?: AbortSignal;
+  }): Promise<Experimental_SandboxProcess> {
+    abortSignal?.throwIfAborted();
+
+    const live = await this.sandbox.runCommand({
+      cmd: 'bash',
+      args: ['-c', command],
+      detached: true,
+      ...(workingDirectory !== undefined ? { cwd: workingDirectory } : {}),
+      ...(env !== undefined ? { env } : {}),
+      ...(abortSignal !== undefined ? { signal: abortSignal } : {}),
+    });
+
+    return createSandboxProcess(live, abortSignal);
+  }
+
+  async readFile({
+    path,
+    abortSignal,
+  }: {
+    path: string;
+    abortSignal?: AbortSignal;
+  }): Promise<ReadableStream<Uint8Array> | null> {
+    const bytes = await this.readBinaryFile({ path, abortSignal });
+    if (bytes == null) return null;
+    return bytesToStream(bytes);
+  }
+
+  async readBinaryFile({
+    path,
+    abortSignal,
+  }: {
+    path: string;
+    abortSignal?: AbortSignal;
+  }): Promise<Uint8Array | null> {
+    abortSignal?.throwIfAborted();
+    try {
+      const buffer = await this.sandbox.readFileToBuffer(
+        { path },
+        abortSignal ? { signal: abortSignal } : undefined,
+      );
+      if (buffer == null) return null;
+      return new Uint8Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength,
+      );
+    } catch (error) {
+      if (isFileNotFoundError(error)) return null;
+      throw error;
+    }
+  }
+
+  async readTextFile({
+    path,
+    encoding = 'utf-8',
+    startLine,
+    endLine,
+    abortSignal,
+  }: {
+    path: string;
+    encoding?: string;
+    startLine?: number;
+    endLine?: number;
+    abortSignal?: AbortSignal;
+  }): Promise<string | null> {
+    const bytes = await this.readBinaryFile({ path, abortSignal });
+    if (bytes == null) return null;
+    const text = Buffer.from(bytes).toString(encoding as BufferEncoding);
+    return extractLines({ text, startLine, endLine });
+  }
+
+  async writeFile({
+    path,
+    content,
+    abortSignal,
+  }: {
+    path: string;
+    content: ReadableStream<Uint8Array>;
+    abortSignal?: AbortSignal;
+  }): Promise<void> {
+    const bytes = await collectStream(content);
+    await this.writeBinaryFile({ path, content: bytes, abortSignal });
+  }
+
+  async writeBinaryFile({
+    path,
+    content,
+    abortSignal,
+  }: {
+    path: string;
+    content: Uint8Array;
+    abortSignal?: AbortSignal;
+  }): Promise<void> {
+    abortSignal?.throwIfAborted();
+    const parent = posix.dirname(path);
+    if (parent && parent !== '.' && parent !== '/') {
+      await this.sandbox.runCommand({
+        cmd: 'mkdir',
+        args: ['-p', parent],
+        ...(abortSignal !== undefined ? { signal: abortSignal } : {}),
+      });
+    }
+    await this.sandbox.writeFiles(
+      [{ path, content }],
+      abortSignal ? { signal: abortSignal } : undefined,
+    );
+  }
+
+  async writeTextFile({
+    path,
+    content,
+    encoding = 'utf-8',
+    abortSignal,
+  }: {
+    path: string;
+    content: string;
+    encoding?: string;
+    abortSignal?: AbortSignal;
+  }): Promise<void> {
+    const buffer = Buffer.from(content, encoding as BufferEncoding);
+    await this.writeBinaryFile({
+      path,
+      content: new Uint8Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength,
+      ),
+      abortSignal,
+    });
+  }
+}
+
+function createSandboxProcess(
+  command: Command,
+  abortSignal: AbortSignal | undefined,
+): Experimental_SandboxProcess {
+  const encoder = new TextEncoder();
+  const controllers: {
+    stdout?: ReadableStreamDefaultController<Uint8Array>;
+    stderr?: ReadableStreamDefaultController<Uint8Array>;
+  } = {};
+
+  const stdout = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controllers.stdout = controller;
+    },
+  });
+
+  const stderr = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controllers.stderr = controller;
+    },
+  });
+
+  const drained = (async () => {
+    try {
+      const iterator = abortSignal
+        ? command.logs({ signal: abortSignal })
+        : command.logs();
+      for await (const message of iterator) {
+        const target =
+          message.stream === 'stdout' ? controllers.stdout : controllers.stderr;
+        target?.enqueue(encoder.encode(message.data));
+      }
+      controllers.stdout?.close();
+      controllers.stderr?.close();
+    } catch (error) {
+      controllers.stdout?.error(error);
+      controllers.stderr?.error(error);
+    }
+  })();
+
+  return {
+    stdout,
+    stderr,
+    async wait(): Promise<{ exitCode: number }> {
+      const finished = await command.wait();
+      await drained;
+      if (abortSignal?.aborted) {
+        throw abortSignal.reason ?? new DOMException('Aborted', 'AbortError');
+      }
+      return { exitCode: finished.exitCode };
+    },
+    async kill(): Promise<void> {
+      await command.kill();
+    },
+  };
+}
+
+function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+}
+
+async function collectStream(
+  stream: ReadableStream<Uint8Array>,
+): Promise<Uint8Array> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+
+function isFileNotFoundError(error: unknown): boolean {
+  if (error == null || typeof error !== 'object') return false;
+  const code = (error as { code?: unknown }).code;
+  if (code === 'ENOENT') return true;
+  const message = (error as { message?: unknown }).message;
+  return (
+    typeof message === 'string' &&
+    /no such file|not found|does not exist|ENOENT/i.test(message)
+  );
+}

package/src/vercel-sandbox.ts

@@ -0,0 +1,288 @@
+import type {
+  HarnessV1NetworkSandboxSession,
+  HarnessV1SandboxProvider,
+} from '@ai-sdk/harness';
+import type { Experimental_SandboxSession as SandboxSession } from '@ai-sdk/provider-utils';
+import { Sandbox } from '@vercel/sandbox';
+import { VercelNetworkSandboxSession } from './vercel-network-sandbox-session';
+import { VercelSandboxSession } from './vercel-sandbox-session';
+
+/**
+ * Flattens an intersection of object types into a single object type so the
+ * resolved shape displays as its named properties rather than a chain of
+ * `A & B & C`.
+ */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+
+/**
+ * Distributes `Omit` across each member of a union instead of collapsing the
+ * union to its common keys. `Sandbox.create`'s parameter is a union (a
+ * git/tarball/no-source create variant and a snapshot-source create variant),
+ * so a plain `Omit` would discard keys absent from any one member (e.g.
+ * `runtime`, which the snapshot variant lacks) and merge the `source` shapes.
+ * Applying `Omit` per-member preserves every variant intact; the `Prettify`
+ * wrapper collapses each member's intersections into a readable object shape.
+ */
+type DistributiveOmit<T, K extends keyof any> = T extends unknown
+  ? Prettify<Omit<T, K>>
+  : never;
+
+/**
+ * Parameters forwarded to `@vercel/sandbox`'s `Sandbox.create` when creating
+ * a sandbox from scratch. Aliased directly from the underlying SDK so the
+ * full surface — every option Vercel supports, including its native
+ * `NetworkPolicy` — is available without us re-declaring it.
+ */
+type VercelSandboxCreateParams = DistributiveOmit<
+  NonNullable<Parameters<typeof Sandbox.create>[0]>,
+  'onResume'
+>;
+
+/**
+ * Settings for {@link createVercelSandbox}. Two mutually-exclusive shapes:
+ *
+ * - `{ sandbox }` — wrap an already-created `@vercel/sandbox` `Sandbox`. The
+ *   caller owns its lifecycle; the provider's `stop()` and `destroy()` are
+ *   no-ops. Optionally declare `bridgePorts` to give the harness a port pool to
+ *   lease from for concurrent sessions on the same provided sandbox.
+ * - {@link VercelSandboxCreateParams} fields — provider creates the underlying
+ *   sandbox. When the adapter declares a bootstrap recipe the provider uses
+ *   `Sandbox.getOrCreate` to maintain a persistent named template snapshot
+ *   keyed by the recipe identity, and forks an ephemeral sandbox per session
+ *   from the snapshot. Use `name` to override the auto-derived template name.
+ */
+export type VercelSandboxSettings =
+  | {
+      sandbox: Sandbox;
+      bridgePorts?: ReadonlyArray<number>;
+    }
+  | (VercelSandboxCreateParams & {
+      sandbox?: never;
+      name?: string;
+    });
+
+/**
+ * 30 minutes. The `@vercel/sandbox` SDK defaults to 5 minutes which is
+ * too short for multi-step workflows — the VM expires between steps.
+ */
+const DEFAULT_SANDBOX_TIMEOUT_MS = 30 * 60 * 1_000;
+
+const VERCEL_PROVIDER_ID = 'vercel-sandbox';
+const TEMPLATE_NAME_PREFIX = 'ai-sdk-harness';
+const SESSION_NAME_PREFIX = 'ai-sdk-harness-session';
+const SNAPSHOT_POLL_INTERVAL_MS = 500;
+const SNAPSHOT_POLL_TIMEOUT_MS = 30_000;
+
+function sessionSandboxName(sessionId: string): string {
+  return `${SESSION_NAME_PREFIX}-${sessionId}`;
+}
+
+export function createVercelSandbox(
+  settings: VercelSandboxSettings = {} as VercelSandboxSettings,
+): HarnessV1SandboxProvider {
+  return new VercelSandboxProvider(settings);
+}
+
+/**
+ * `HarnessV1SandboxProvider` implementation backed by `@vercel/sandbox`.
+ * Construct one via {@link createVercelSandbox} at module scope and pass it
+ * to a `HarnessAgent` (or call `createSession()` directly if you want raw
+ * access to a network sandbox session).
+ */
+export class VercelSandboxProvider implements HarnessV1SandboxProvider {
+  readonly specificationVersion = 'harness-sandbox-v1' as const;
+  readonly providerId = VERCEL_PROVIDER_ID;
+  readonly bridgePorts?: ReadonlyArray<number>;
+
+  constructor(private readonly settings: VercelSandboxSettings) {
+    if (
+      'sandbox' in settings &&
+      settings.sandbox != null &&
+      settings.bridgePorts != null &&
+      settings.bridgePorts.length > 0
+    ) {
+      this.bridgePorts = [...settings.bridgePorts];
+    }
+  }
+
+  createSession = async (options?: {
+    sessionId?: string;
+    abortSignal?: AbortSignal;
+    identity?: string;
+    onFirstCreate?: (
+      session: SandboxSession,
+      opts: { abortSignal?: AbortSignal },
+    ) => Promise<void>;
+  }): Promise<HarnessV1NetworkSandboxSession> => {
+    options?.abortSignal?.throwIfAborted();
+
+    if ('sandbox' in this.settings && this.settings.sandbox != null) {
+      return new VercelNetworkSandboxSession({
+        sandbox: this.settings.sandbox,
+        ownsLifecycle: false,
+      });
+    }
+
+    type CreateNewBranch = BaseCreateSandboxParams & {
+      sandbox?: never;
+      name?: string;
+    };
+    const settings = this.settings as CreateNewBranch;
+    const {
+      sandbox: _ignoredSandbox,
+      name: explicitName,
+      ...createParams
+    } = settings;
+    const baseParams: BaseCreateSandboxParams = {
+      ...createParams,
+      timeout: createParams.timeout ?? DEFAULT_SANDBOX_TIMEOUT_MS,
+    };
+
+    const identity = options?.identity;
+    const onFirstCreate = options?.onFirstCreate;
+
+    // When sessionId is supplied, name the per-session sandbox deterministically
+    // so a future `resumeSession({ sessionId })` can locate it via
+    // `Sandbox.get({ name })`. Absent sessionId (e.g. prewarm), fall back to
+    // Vercel's auto-naming.
+    const sessionNameOverride = options?.sessionId
+      ? { name: sessionSandboxName(options.sessionId) }
+      : {};
+
+    if (identity == null || onFirstCreate == null) {
+      const sandbox = await Sandbox.create({
+        ...baseParams,
+        ...sessionNameOverride,
+        ...(options?.abortSignal ? { signal: options.abortSignal } : {}),
+      });
+      return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
+    }
+
+    const templateName = explicitName ?? `${TEMPLATE_NAME_PREFIX}-${identity}`;
+    const cache = getSnapshotCache();
+    let snapshotId = cache.get(templateName);
+
+    if (snapshotId == null) {
+      const template = await Sandbox.getOrCreate({
+        ...baseParams,
+        name: templateName,
+        persistent: true,
+        snapshotExpiration: baseParams.snapshotExpiration ?? 0,
+        onCreate: async sbx => {
+          await onFirstCreate(new VercelSandboxSession(sbx), {
+            abortSignal: options?.abortSignal,
+          });
+        },
+        ...(options?.abortSignal ? { signal: options.abortSignal } : {}),
+      });
+
+      let resolvedId: string | undefined = template.currentSnapshotId;
+      if (resolvedId == null) {
+        const stopResult = await template.stop(
+          options?.abortSignal ? { signal: options.abortSignal } : undefined,
+        );
+        resolvedId = stopResult.snapshot?.id;
+        if (resolvedId == null) {
+          resolvedId = await pollForTemplateSnapshot(
+            templateName,
+            options?.abortSignal,
+          );
+        }
+      }
+
+      cache.set(templateName, resolvedId);
+      snapshotId = resolvedId;
+    }
+
+    const {
+      runtime: _ignoredRuntime,
+      source: _ignoredSource,
+      persistent: _ignoredPersistent,
+      ...forkParams
+    } = baseParams;
+
+    const fork = await Sandbox.create({
+      ...forkParams,
+      source: { type: 'snapshot', snapshotId },
+      ...sessionNameOverride,
+      ...(options?.abortSignal ? { signal: options.abortSignal } : {}),
+    });
+    return new VercelNetworkSandboxSession({
+      sandbox: fork,
+      ownsLifecycle: true,
+    });
+  };
+
+  resumeSession = async (options: {
+    sessionId: string;
+    abortSignal?: AbortSignal;
+  }): Promise<HarnessV1NetworkSandboxSession> => {
+    options.abortSignal?.throwIfAborted();
+
+    // Wrap-existing case: caller owns the sandbox. Same session as createSession.
+    if ('sandbox' in this.settings && this.settings.sandbox != null) {
+      return new VercelNetworkSandboxSession({
+        sandbox: this.settings.sandbox,
+        ownsLifecycle: false,
+      });
+    }
+
+    const sandbox = await Sandbox.get({
+      name: sessionSandboxName(options.sessionId),
+      ...(options.abortSignal ? { signal: options.abortSignal } : {}),
+    });
+    return new VercelNetworkSandboxSession({ sandbox, ownsLifecycle: true });
+  };
+}
+
+/**
+ * Base shape of `Sandbox.create` params extracted from the union (excludes
+ * the `source: { type: 'snapshot' }` variant) so all create-time fields
+ * are typed as present.
+ */
+type BaseCreateSandboxParams = Exclude<
+  VercelSandboxCreateParams,
+  { source: { type: 'snapshot'; snapshotId: string } }
+>;
+
+const SNAPSHOT_CACHE_KEY = Symbol.for(
+  'ai-sdk.harness.vercel-template-snapshots',
+);
+
+type SnapshotCache = Map<string, string>;
+
+function getSnapshotCache(): SnapshotCache {
+  const globals = globalThis as {
+    [SNAPSHOT_CACHE_KEY]?: SnapshotCache;
+  };
+  let cache = globals[SNAPSHOT_CACHE_KEY];
+  if (cache == null) {
+    cache = new Map();
+    globals[SNAPSHOT_CACHE_KEY] = cache;
+  }
+  return cache;
+}
+
+async function pollForTemplateSnapshot(
+  name: string,
+  abortSignal: AbortSignal | undefined,
+): Promise<string> {
+  const deadline = Date.now() + SNAPSHOT_POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    abortSignal?.throwIfAborted();
+    const refreshed = await Sandbox.get({
+      name,
+      resume: false,
+      ...(abortSignal ? { signal: abortSignal } : {}),
+    });
+    if (refreshed.currentSnapshotId) {
+      return refreshed.currentSnapshotId;
+    }
+    await new Promise<void>(resolve =>
+      setTimeout(resolve, SNAPSHOT_POLL_INTERVAL_MS),
+    );
+  }
+  throw new Error(
+    `Timed out waiting for snapshot of template "${name}" to publish.`,
+  );
+}