@recallkit/web 0.1.1

package/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/next.config.ts

@@ -0,0 +1,13 @@
+import type { NextConfig } from "next";
+import fs from "node:fs";
+import path from "node:path";
+
+const monorepoRoot = path.join(process.cwd(), "../..");
+const isMonorepo = fs.existsSync(path.join(monorepoRoot, "pnpm-workspace.yaml"));
+
+const nextConfig: NextConfig = {
+  transpilePackages: ["@recallkit/core"],
+  ...(isMonorepo ? { outputFileTracingRoot: monorepoRoot } : {}),
+};
+
+export default nextConfig;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@recallkit/web",
+  "version": "0.1.1",
+  "type": "module",
+  "dependencies": {
+    "@arkiv-network/sdk": "^0.6.8",
+    "lucide-react": "^1.16.0",
+    "next": "^16.2.6",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "viem": "^2.50.4",
+    "@recallkit/core": "0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "public",
+    "next.config.ts",
+    "tsconfig.json",
+    "next-env.d.ts"
+  ],
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "dev": "next dev -p ${RECALLKIT_PORT:-4317}",
+    "build": "next build",
+    "start": "next start -p ${RECALLKIT_PORT:-4317}",
+    "typecheck": "next typegen && tsc -p tsconfig.json --noEmit",
+    "lint": "next typegen && tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/app/api/_lib/guards.ts

@@ -0,0 +1,35 @@
+export const PENDING_ID_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isStringArray(value: unknown, maxItems: number, maxLength: number): value is string[] {
+  return (
+    Array.isArray(value) &&
+    value.length <= maxItems &&
+    value.every((item) => typeof item === "string" && item.length > 0 && item.length <= maxLength)
+  );
+}
+
+export function isStringRecord(
+  value: unknown,
+  maxKeys: number,
+  maxLength: number,
+): value is Record<string, string> {
+  if (!isRecord(value)) return false;
+  const entries = Object.entries(value);
+  return (
+    entries.length <= maxKeys &&
+    entries.every(
+      ([key, entryValue]) =>
+        key.length <= maxLength &&
+        typeof entryValue === "string" &&
+        entryValue.length <= maxLength,
+    )
+  );
+}
+
+export function isEvmAddress(value: string): boolean {
+  return /^0x[a-fA-F0-9]{40}$/.test(value);
+}

package/src/app/api/_lib/limits.ts

@@ -0,0 +1,6 @@
+export const MAX_MEMORY_TEXT_LENGTH = 4_000;
+export const MAX_REASON_LENGTH = 1_000;
+export const MAX_ID_LENGTH = 128;
+export const MAX_PENDING_IDS = 100;
+export const MAX_PACKS = 20;
+export const MAX_ENTITY_KEYS = 20;

package/src/app/api/_lib/responses.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+
+export function badRequest(error: string) {
+  return NextResponse.json({ ok: false, error }, { status: 400 });
+}
+
+export function notFound(error: string) {
+  return NextResponse.json({ ok: false, error }, { status: 404 });
+}

package/src/app/api/commit/complete/route.ts

@@ -0,0 +1,112 @@
+import {
+  clearCommittedPending,
+  isCachedMemoryPackPayload,
+  isMemoryIndexCheckpointPayload,
+  readCacheJson,
+  readConfig,
+  type MemoryIndexCheckpointPayload,
+  type CachedMemoryPackPayload,
+  writeCacheJson,
+} from "@recallkit/core";
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../../security";
+import { isRecord, isStringArray, isStringRecord } from "../../_lib/guards";
+import {
+  MAX_ENTITY_KEYS,
+  MAX_ID_LENGTH,
+  MAX_PACKS,
+  MAX_PENDING_IDS,
+} from "../../_lib/limits";
+import { badRequest } from "../../_lib/responses";
+
+export async function POST(request: Request) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  const body = await request.json();
+  const validation = await validateCommitCompleteBody(body);
+  if (!validation.ok) return badRequest(validation.error);
+
+  const { pendingIds, indexCheckpoint, packs, entityKeys } = validation.body;
+  if (indexCheckpoint) {
+    await writeCacheJson("latest-index.json", indexCheckpoint);
+  }
+  if (packs) {
+    const existingPacks = (await readCacheJson<CachedMemoryPackPayload[]>("latest-packs.json")) ?? [];
+    await writeCacheJson("latest-packs.json", mergeMemoryPacks(existingPacks, packs));
+  }
+  if (pendingIds.length) {
+    await clearCommittedPending(pendingIds);
+  }
+
+  return NextResponse.json({ ok: true, entityKeys });
+}
+
+type CommitCompleteBody = {
+  pendingIds: string[];
+  indexCheckpoint?: MemoryIndexCheckpointPayload;
+  packs?: CachedMemoryPackPayload[];
+  entityKeys: Record<string, string>;
+};
+
+type ValidationResult =
+  | { ok: true; body: CommitCompleteBody }
+  | { ok: false; error: string };
+
+async function validateCommitCompleteBody(body: unknown): Promise<ValidationResult> {
+  if (!isRecord(body)) return { ok: false, error: "Request body must be an object." };
+
+  const pendingIds = body.pendingIds ?? [];
+  if (!isStringArray(pendingIds, MAX_PENDING_IDS, MAX_ID_LENGTH)) {
+    return { ok: false, error: "pendingIds must be a bounded array of strings." };
+  }
+
+  const entityKeys = body.entityKeys ?? {};
+  if (!isStringRecord(entityKeys, MAX_ENTITY_KEYS, MAX_ID_LENGTH)) {
+    return { ok: false, error: "entityKeys must be a bounded object of strings." };
+  }
+
+  const indexCheckpoint = body.indexCheckpoint;
+  if (indexCheckpoint !== undefined && !isMemoryIndexCheckpointPayload(indexCheckpoint)) {
+    return { ok: false, error: "indexCheckpoint is invalid." };
+  }
+
+  const packs = body.packs;
+  if (packs !== undefined && !isCachedMemoryPackArray(packs)) {
+    return { ok: false, error: "packs must be a bounded array of memory packs." };
+  }
+
+  const ownerWallet = indexCheckpoint?.ownerWallet ?? packs?.[0]?.ownerWallet;
+  if (ownerWallet && packs?.some((pack) => pack.ownerWallet.toLowerCase() !== ownerWallet.toLowerCase())) {
+    return { ok: false, error: "All committed packs must use the same owner wallet." };
+  }
+
+  const config = await readConfig();
+  if (config.ownerWallet && ownerWallet && config.ownerWallet.toLowerCase() !== ownerWallet.toLowerCase()) {
+    return { ok: false, error: "Commit owner wallet does not match the connected wallet." };
+  }
+
+  return {
+    ok: true,
+    body: {
+      pendingIds,
+      ...(indexCheckpoint ? { indexCheckpoint } : {}),
+      ...(packs ? { packs } : {}),
+      entityKeys,
+    },
+  };
+}
+
+function isCachedMemoryPackArray(value: unknown): value is CachedMemoryPackPayload[] {
+  return Array.isArray(value) && value.length <= MAX_PACKS && value.every(isCachedMemoryPackPayload);
+}
+
+function mergeMemoryPacks(
+  existingPacks: CachedMemoryPackPayload[],
+  newPacks: CachedMemoryPackPayload[],
+): CachedMemoryPackPayload[] {
+  const byEntityKey = new Map<string, CachedMemoryPackPayload>();
+  for (const pack of existingPacks) byEntityKey.set(pack.entityKey, pack);
+  for (const pack of newPacks) byEntityKey.set(pack.entityKey, pack);
+  return [...byEntityKey.values()];
+}

package/src/app/api/commit/preview/route.ts

@@ -0,0 +1,71 @@
+import {
+  createConsolidatedMemory,
+  detectConflicts,
+  markSuperseded,
+  normalizeMemoryScope,
+  pendingToMemoryRecord,
+  readCacheJson,
+  readConfig,
+  readPendingMemories,
+  type MemoryIndexCheckpointPayload,
+  type PendingMemoryCandidate,
+} from "@recallkit/core";
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../../security";
+import { isRecord, isStringArray } from "../../_lib/guards";
+import { MAX_ID_LENGTH, MAX_PENDING_IDS } from "../../_lib/limits";
+import { badRequest } from "../../_lib/responses";
+
+export async function POST(request: Request) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  const body = await request.json();
+  if (!isRecord(body) || !isStringArray(body.ids, MAX_PENDING_IDS, MAX_ID_LENGTH)) {
+    return badRequest("ids must be a bounded array of strings.");
+  }
+
+  const selected = new Set(body.ids);
+  const [pending, config, index] = await Promise.all([
+    readPendingMemories(),
+    readConfig(),
+    readCacheJson<MemoryIndexCheckpointPayload>("latest-index.json"),
+  ]);
+
+  if (!config.ownerWallet) {
+    return badRequest("Connect a wallet before previewing commit.");
+  }
+
+  const selectedCandidates = pending.filter((candidate) => selected.has(candidate.id));
+  const candidates = selectedCandidates.filter(isCommittableCandidate);
+  const compiledMemories = candidates.map((candidate) =>
+    pendingToMemoryRecord(candidate, config.ownerWallet!),
+  );
+  const consolidated = createConsolidatedMemory(compiledMemories);
+  const memories = consolidated ? [...compiledMemories, consolidated] : compiledMemories;
+  const conflicts = detectConflicts(memories, index?.entries ?? []);
+  const baseIndexEntries = markSuperseded(index?.entries ?? [], conflicts);
+
+  return NextResponse.json({
+    ok: true,
+    signerWallet: config.ownerWallet,
+    network: "arkiv-braga",
+    selectedCount: selectedCandidates.length,
+    committablePendingIds: candidates.map((candidate) => candidate.id),
+    sessionDraftCount: selectedCandidates.filter(isSessionCandidate).length,
+    entities: ["memory_pack", "memory_index_checkpoint", "memory_commit", "memory_manifest"],
+    estimatedWrites: 4,
+    encryption: "enabled",
+    memories,
+    conflicts,
+    baseIndexEntries,
+  });
+}
+
+function isCommittableCandidate(candidate: PendingMemoryCandidate): boolean {
+  return candidate.status === "approved" && !isSessionCandidate(candidate);
+}
+
+function isSessionCandidate(candidate: PendingMemoryCandidate): boolean {
+  return normalizeMemoryScope(candidate.scope).level === "session";
+}

package/src/app/api/commit/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../security";
+
+export async function POST(request: Request) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  return NextResponse.json(
+    {
+      ok: false,
+      error:
+        "Commit must be executed from the approval app context so the connected wallet signs Arkiv writes.",
+    },
+    { status: 400 },
+  );
+}

package/src/app/api/memory-cache/route.ts

@@ -0,0 +1,50 @@
+import { readCacheJson, type MemoryPackPayload } from "@recallkit/core";
+import { NextResponse } from "next/server";
+
+const MAX_PACKS = 20;
+const MAX_MEMORIES = 8;
+
+type CachedMemorySummary = {
+  id: string;
+  kind: string;
+  summary: string;
+  retrieval: { importance: number };
+  evidence: { confidence: number; source: string };
+};
+
+type CachePackSummary = {
+  memories: CachedMemorySummary[];
+};
+
+export async function GET() {
+  const packs = (await readCacheJson<MemoryPackPayload[]>("latest-packs.json")) ?? [];
+
+  return NextResponse.json({
+    packs: summarizePacks(packs),
+  });
+}
+
+function summarizePacks(packs: MemoryPackPayload[]): CachePackSummary[] {
+  let remaining = MAX_MEMORIES;
+  const summaries: CachePackSummary[] = [];
+
+  for (const pack of packs.slice(0, MAX_PACKS)) {
+    if (remaining <= 0) break;
+
+    const memories = pack.memories.slice(0, remaining).map((memory) => ({
+      id: memory.id,
+      kind: memory.kind,
+      summary: memory.summary,
+      retrieval: { importance: memory.retrieval.importance },
+      evidence: {
+        confidence: memory.evidence.confidence,
+        source: memory.evidence.source,
+      },
+    }));
+
+    remaining -= memories.length;
+    if (memories.length > 0) summaries.push({ memories });
+  }
+
+  return summaries;
+}

package/src/app/api/pending/[id]/delete/route.ts

@@ -0,0 +1,21 @@
+import { deletePendingMemory } from "@recallkit/core";
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../../../security";
+import { PENDING_ID_PATTERN } from "../../../_lib/guards";
+import { badRequest } from "../../../_lib/responses";
+
+export async function POST(
+  request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  const params = await context.params;
+  if (!PENDING_ID_PATTERN.test(params.id)) {
+    return badRequest("Invalid pending memory id.");
+  }
+
+  const deleted = await deletePendingMemory(params.id);
+  return NextResponse.json({ ok: deleted });
+}

package/src/app/api/pending/[id]/route.ts

@@ -0,0 +1,47 @@
+import { isPendingMemoryStatus, normalizeMemoryScope, updatePendingMemory } from "@recallkit/core";
+import type { MemoryScope } from "@recallkit/core/schemas";
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../../security";
+import { isRecord, PENDING_ID_PATTERN } from "../../_lib/guards";
+import { MAX_MEMORY_TEXT_LENGTH, MAX_REASON_LENGTH } from "../../_lib/limits";
+import { badRequest, notFound } from "../../_lib/responses";
+
+export async function PATCH(
+  request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  const params = await context.params;
+  if (!PENDING_ID_PATTERN.test(params.id)) {
+    return badRequest("Invalid pending memory id.");
+  }
+
+  const body = await request.json();
+  if (!isRecord(body)) {
+    return badRequest("Request body must be an object.");
+  }
+  if (typeof body.text === "string" && body.text.length > MAX_MEMORY_TEXT_LENGTH) {
+    return badRequest("text is too long");
+  }
+  if (typeof body.reason === "string" && body.reason.length > MAX_REASON_LENGTH) {
+    return badRequest("reason is too long");
+  }
+  if (typeof body.scopeReason === "string" && body.scopeReason.length > MAX_REASON_LENGTH) {
+    return badRequest("scopeReason is too long");
+  }
+
+  const updated = await updatePendingMemory(params.id, {
+    ...(typeof body.text === "string" ? { text: body.text } : {}),
+    ...(typeof body.reason === "string" ? { reason: body.reason } : {}),
+    ...(typeof body.importance === "number" ? { importance: body.importance } : {}),
+    ...(isRecord(body.scope) ? { scope: normalizeMemoryScope(body.scope as Partial<MemoryScope>) } : {}),
+    ...(typeof body.scopeReason === "string" ? { scopeReason: body.scopeReason } : {}),
+    ...(isPendingMemoryStatus(body.status) ? { status: body.status } : {}),
+  });
+
+  if (!updated) return notFound("Memory draft not found.");
+
+  return NextResponse.json({ ok: true, candidate: updated });
+}

package/src/app/api/pending/route.ts

@@ -0,0 +1,41 @@
+import { addPendingMemory, compileMemoryCandidate, readPendingMemories } from "@recallkit/core";
+import type { SuggestMemoryInput } from "@recallkit/core";
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../security";
+import { isRecord } from "../_lib/guards";
+import { MAX_MEMORY_TEXT_LENGTH, MAX_REASON_LENGTH } from "../_lib/limits";
+import { badRequest } from "../_lib/responses";
+
+export async function GET() {
+  const pending = await readPendingMemories();
+  return NextResponse.json({ pending });
+}
+
+export async function POST(request: Request) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  const body = await request.json();
+  if (!isRecord(body) || !isRecord(body.candidate)) {
+    return badRequest("candidate.text is required");
+  }
+  const candidateInput = body.candidate as SuggestMemoryInput;
+  if (!candidateInput.text) {
+    return badRequest("candidate.text is required");
+  }
+  if (candidateInput.text.length > MAX_MEMORY_TEXT_LENGTH) {
+    return badRequest("candidate.text is too long");
+  }
+  if (candidateInput.reason && candidateInput.reason.length > MAX_REASON_LENGTH) {
+    return badRequest("candidate.reason is too long");
+  }
+
+  const candidate = compileMemoryCandidate(candidateInput, "skill");
+  await addPendingMemory(candidate);
+
+  return NextResponse.json({
+    ok: true,
+    pendingId: candidate.id,
+    message: "Memory draft saved. It will only be committed to Arkiv after you approve and sign it.",
+  });
+}

package/src/app/api/security.ts

@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+
+export function rejectCrossOriginMutation(request: Request): NextResponse | undefined {
+  const origin = request.headers.get("origin");
+  if (!origin) return undefined;
+
+  const host = request.headers.get("host");
+  if (!host) {
+    return NextResponse.json({ ok: false, error: "Missing host header." }, { status: 403 });
+  }
+
+  let originHost: string;
+  try {
+    originHost = new URL(origin).host;
+  } catch (error) {
+    console.warn("Invalid origin header", error);
+    return NextResponse.json({ ok: false, error: "Invalid origin header." }, { status: 403 });
+  }
+
+  if (originHost !== host) {
+    return NextResponse.json({ ok: false, error: "Cross-origin request blocked." }, { status: 403 });
+  }
+
+  return undefined;
+}

package/src/app/api/status/route.ts

@@ -0,0 +1,35 @@
+import { getWalletStatus, writeConfig } from "@recallkit/core";
+import { NextResponse } from "next/server";
+import { rejectCrossOriginMutation } from "../security";
+import { isEvmAddress, isRecord } from "../_lib/guards";
+import { badRequest } from "../_lib/responses";
+
+export async function GET() {
+  return NextResponse.json(await getWalletStatus());
+}
+
+export async function POST(request: Request) {
+  const rejected = rejectCrossOriginMutation(request);
+  if (rejected) return rejected;
+
+  const body = await request.json();
+  if (!isRecord(body)) return badRequest("Request body must be an object.");
+  if (body.ownerWallet !== undefined && typeof body.ownerWallet !== "string") {
+    return badRequest("ownerWallet must be a string.");
+  }
+  if (body.ownerWallet && !isEvmAddress(body.ownerWallet)) {
+    return badRequest("ownerWallet must be an EVM address.");
+  }
+
+  const config = await writeConfig({
+    arkivChain: "braga",
+    ...(body.ownerWallet ? { ownerWallet: body.ownerWallet } : {}),
+  });
+
+  return NextResponse.json({
+    connected: Boolean(config.ownerWallet),
+    ownerWallet: config.ownerWallet,
+    network: config.ownerWallet ? config.arkivChain : undefined,
+    approvalAppUrl: config.approvalAppUrl,
+  });
+}

package/src/app/dashboard/page.tsx

@@ -0,0 +1,57 @@
+import Link from "next/link";
+import { getWalletStatus, readPendingMemories } from "@recallkit/core";
+import { RetrievedMemories } from "@/components/RetrievedMemories";
+import { ArrowRightIcon } from "@/components/ArrowRightIcon";
+
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
+export default async function DashboardPage() {
+  const [pending, status] = await Promise.all([
+    readPendingMemories(),
+    getWalletStatus(),
+  ]);
+
+  return (
+    <section className="page">
+      <div className="page-header">
+        <div className="page-header__title">
+          <div className="eyebrow">/ overview</div>
+          <h1 className="h1">Memory overview</h1>
+          <p className="lede">
+            Wallet-owned encrypted memory for AI agents. Review memory drafts, then sign approved commits.
+          </p>
+        </div>
+        <div className="page-header__actions">
+          <Link href="/drafts" className="btn btn--primary">
+            Review drafts
+            <ArrowRightIcon />
+          </Link>
+        </div>
+      </div>
+
+      <div className="stat-grid" style={{ gridTemplateColumns: "repeat(3, 1fr)" }}>
+        <div className="stat-grid__cell">
+          <div className="stat-grid__label">Arkiv Braga status</div>
+          <div
+            className={`stat-grid__value${status.connected ? " stat-grid__value--accent" : ""}`}
+          >
+            {status.connected ? "Ready" : "Wallet needed"}
+          </div>
+        </div>
+        <div className="stat-grid__cell">
+          <div className="stat-grid__label">Memory drafts</div>
+          <div className="stat-grid__value">{pending.length}</div>
+        </div>
+        <div className="stat-grid__cell">
+          <div className="stat-grid__label">Signing policy</div>
+          <div className="stat-grid__value" style={{ fontSize: 16, paddingTop: 6 }}>
+            Wallet only
+          </div>
+        </div>
+      </div>
+
+      <RetrievedMemories />
+    </section>
+  );
+}

package/src/app/drafts/page.tsx

@@ -0,0 +1,5 @@
+import { MemoryInbox } from "@/components/MemoryInbox";
+
+export default function InboxPage() {
+  return <MemoryInbox />;
+}

package/src/app/globals.css

@@ -0,0 +1,10 @@
+@import "../styles/tokens.css";
+@import "../styles/base.css";
+@import "../styles/buttons.css";
+@import "../styles/navigation.css";
+@import "../styles/layout.css";
+@import "../styles/landing.css";
+@import "../styles/data-display.css";
+@import "../styles/forms.css";
+@import "../styles/overlays.css";
+@import "../styles/utilities.css";

package/src/app/layout.tsx

@@ -0,0 +1,43 @@
+import type { Metadata } from "next";
+import { Inter, Space_Grotesk, JetBrains_Mono } from "next/font/google";
+import { TopNav } from "@/components/TopNav";
+import "./globals.css";
+
+const inter = Inter({
+  subsets: ["latin"],
+  weight: ["400", "500", "600", "700"],
+  display: "swap",
+  variable: "--font-sans",
+});
+
+const spaceGrotesk = Space_Grotesk({
+  subsets: ["latin"],
+  weight: ["400", "500", "600", "700"],
+  display: "swap",
+  variable: "--font-display",
+});
+
+const jetbrainsMono = JetBrains_Mono({
+  subsets: ["latin"],
+  weight: ["400", "500", "600"],
+  display: "swap",
+  variable: "--font-mono",
+});
+
+export const metadata: Metadata = {
+  title: "RecallKit",
+  description: "Wallet-owned encrypted memory for coding agents.",
+};
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode }>) {
+  return (
+    <html lang="en" className={`${inter.variable} ${spaceGrotesk.variable} ${jetbrainsMono.variable}`}>
+      <body>
+        <main className="shell">
+          <TopNav />
+          {children}
+        </main>
+      </body>
+    </html>
+  );
+}