@jcyamacho/agent-memory 0.1.0 → 0.3.0

package/dist/index.js

@@ -2431,9 +2431,9 @@ var require_validate = __commonJS((exports) => {
     }
   }
   function returnResults(it) {
-    const { gen, schemaEnv, validateName, ValidationError, opts } = it;
+    const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it;
     if (schemaEnv.$async) {
-      gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
+      gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError2}(${names_1.default.vErrors})`));
     } else {
       gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
       if (opts.unevaluated)
@@ -2783,14 +2783,14 @@ var require_validate = __commonJS((exports) => {
 var require_validation_error = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
 
-  class ValidationError extends Error {
+  class ValidationError2 extends Error {
     constructor(errors3) {
       super("validation failed");
       this.errors = errors3;
       this.ajv = this.validation = true;
     }
   }
-  exports.default = ValidationError;
+  exports.default = ValidationError2;
 });
 
 // node_modules/ajv/dist/compile/ref_error.js
@@ -11543,7 +11543,7 @@ var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || t
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
 var TaskCreationParamsSchema = looseObject({
-  ttl: union([number2(), _null3()]).optional(),
+  ttl: number2().optional(),
   pollInterval: number2().optional()
 });
 var TaskMetadataSchema = object({
@@ -11697,7 +11697,8 @@ var ClientCapabilitiesSchema = object({
   roots: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   protocolVersion: string2(),
@@ -11722,7 +11723,8 @@ var ServerCapabilitiesSchema = object({
   tools: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: string2(),
@@ -11837,6 +11839,7 @@ var ResourceSchema = object({
   uri: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  size: optional(number2()),
   annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
@@ -12464,33 +12467,268 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.1.0";
+var version2 = "0.3.0";
 
 // src/config.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { parseArgs } from "node:util";
-var AGENT_MEMORY_DB_PATH_ENV = "AGENT_MEMORY_DB_PATH";
-var DEFAULT_UI_PORT = 6580;
-function resolveConfig(environment = process.env, argv = process.argv.slice(2)) {
-  const { values } = parseArgs({
-    args: argv,
-    options: {
-      ui: { type: "boolean", default: false },
-      port: { type: "string", default: String(DEFAULT_UI_PORT) }
-    },
-    strict: false
-  });
+var AGENT_MEMORY_STORE_PATH_ENV = "AGENT_MEMORY_STORE_PATH";
+function resolveConfig(environment = process.env) {
   return {
-    databasePath: resolveDatabasePath(environment),
-    uiMode: Boolean(values.ui),
-    uiPort: Number(values.port) || DEFAULT_UI_PORT
+    storePath: resolveStorePath(environment)
   };
 }
-function resolveDatabasePath(environment = process.env) {
-  return environment[AGENT_MEMORY_DB_PATH_ENV] || join(homedir(), ".config", "agent-memory", "memory.db");
+function resolveStorePath(environment = process.env) {
+  return environment[AGENT_MEMORY_STORE_PATH_ENV] || join(homedir(), ".config", "agent-memory");
+}
+
+// src/filesystem/repository.ts
+import { randomUUID } from "node:crypto";
+import { access, mkdir, readdir, readFile, rename, rm, stat, unlink, utimes, writeFile } from "node:fs/promises";
+import { basename, dirname, join as join2 } from "node:path";
+
+// src/errors.ts
+class MemoryError extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "MemoryError";
+    this.code = code;
+  }
+}
+
+class ValidationError extends MemoryError {
+  constructor(message) {
+    super("VALIDATION_ERROR", message);
+    this.name = "ValidationError";
+  }
+}
+
+class NotFoundError extends MemoryError {
+  constructor(message) {
+    super("NOT_FOUND", message);
+    this.name = "NotFoundError";
+  }
+}
+
+class PersistenceError extends MemoryError {
+  constructor(message, options) {
+    super("PERSISTENCE_ERROR", message, options);
+    this.name = "PersistenceError";
+  }
 }
 
+// src/filesystem/repository.ts
+var DEFAULT_LIST_LIMIT = 15;
+var MARKDOWN_EXTENSION = ".md";
+
+class FilesystemMemoryRepository {
+  globalsDirectory;
+  workspacesDirectory;
+  constructor(storePath) {
+    this.globalsDirectory = join2(storePath, "globals");
+    this.workspacesDirectory = join2(storePath, "workspaces");
+  }
+  async create(input) {
+    try {
+      const id = randomUUID();
+      const updatedAt = new Date;
+      const targetPath = this.memoryPath(id, input.workspace);
+      await this.writeFileAtomically(targetPath, input.content, updatedAt);
+      return this.readRecord({ path: targetPath, workspace: input.workspace });
+    } catch (error2) {
+      throw asPersistenceError("Failed to save memory.", error2);
+    }
+  }
+  async get(id) {
+    try {
+      const located = await this.findMemoryFile(id);
+      if (!located) {
+        return;
+      }
+      return this.readRecord(located);
+    } catch (error2) {
+      throw asPersistenceError("Failed to find memory.", error2);
+    }
+  }
+  async list(options) {
+    try {
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? DEFAULT_LIST_LIMIT;
+      const targets = await this.resolveListTargets(options);
+      const groups = await Promise.all(targets.map((target) => this.readDirectoryRecords(target)));
+      const items = groups.flat().sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime() || left.id.localeCompare(right.id));
+      const pageItems = items.slice(offset, offset + limit);
+      return {
+        items: pageItems,
+        hasMore: offset + limit < items.length
+      };
+    } catch (error2) {
+      throw asPersistenceError("Failed to list memories.", error2);
+    }
+  }
+  async update(input) {
+    const existing = await this.get(input.id);
+    if (!existing) {
+      throw new NotFoundError(`Memory not found: ${input.id}`);
+    }
+    const nextContent = input.content ?? existing.content;
+    const nextWorkspace = input.workspace === undefined ? existing.workspace : input.workspace ?? undefined;
+    if (nextContent === existing.content && nextWorkspace === existing.workspace) {
+      return existing;
+    }
+    const currentPath = this.memoryPath(existing.id, existing.workspace);
+    const targetPath = this.memoryPath(existing.id, nextWorkspace);
+    const updatedAt = new Date;
+    try {
+      await this.writeFileAtomically(targetPath, nextContent, updatedAt);
+      if (targetPath !== currentPath) {
+        await unlink(currentPath);
+        await this.cleanupWorkspaceDirectory(existing.workspace);
+      }
+      return this.readRecord({ path: targetPath, workspace: nextWorkspace });
+    } catch (error2) {
+      throw asPersistenceError("Failed to update memory.", error2);
+    }
+  }
+  async delete(input) {
+    const located = await this.findMemoryFile(input.id);
+    if (!located) {
+      throw new NotFoundError(`Memory not found: ${input.id}`);
+    }
+    try {
+      await unlink(located.path);
+      await this.cleanupWorkspaceDirectory(located.workspace);
+    } catch (error2) {
+      throw asPersistenceError("Failed to delete memory.", error2);
+    }
+  }
+  async listWorkspaces() {
+    try {
+      return (await this.listWorkspaceTargets()).map((target) => target.workspace).sort((left, right) => left.localeCompare(right));
+    } catch (error2) {
+      throw asPersistenceError("Failed to list workspaces.", error2);
+    }
+  }
+  async resolveListTargets(options) {
+    if (options.workspace && options.global) {
+      return [
+        { path: this.globalsDirectory },
+        { path: this.workspaceDirectory(options.workspace), workspace: options.workspace }
+      ];
+    }
+    if (options.workspace) {
+      return [{ path: this.workspaceDirectory(options.workspace), workspace: options.workspace }];
+    }
+    if (options.global) {
+      return [{ path: this.globalsDirectory }];
+    }
+    return [{ path: this.globalsDirectory }, ...await this.listWorkspaceTargets()];
+  }
+  async readDirectoryRecords(target) {
+    const entries = await readDirectory(target.path);
+    const memoryFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(MARKDOWN_EXTENSION));
+    return Promise.all(memoryFiles.map(async (entry) => this.readRecord({
+      path: join2(target.path, entry.name),
+      workspace: target.workspace
+    })));
+  }
+  async findMemoryFile(id) {
+    const globalPath = this.memoryPath(id, undefined);
+    if (await pathExists(globalPath)) {
+      return { path: globalPath };
+    }
+    for (const target of await this.listWorkspaceTargets()) {
+      const filePath = join2(target.path, `${id}${MARKDOWN_EXTENSION}`);
+      if (await pathExists(filePath)) {
+        return { path: filePath, workspace: target.workspace };
+      }
+    }
+    return;
+  }
+  async listWorkspaceTargets() {
+    const entries = await readDirectory(this.workspacesDirectory);
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => ({
+      path: join2(this.workspacesDirectory, entry.name),
+      workspace: decodeWorkspaceSegment(entry.name)
+    }));
+  }
+  async readRecord(located) {
+    const [content, updatedAt] = await Promise.all([readFile(located.path, "utf8"), this.readUpdatedAt(located.path)]);
+    return {
+      id: basename(located.path, MARKDOWN_EXTENSION),
+      content,
+      workspace: located.workspace,
+      updatedAt
+    };
+  }
+  async readUpdatedAt(filePath) {
+    const fileStats = await stat(filePath);
+    return fileStats.mtime;
+  }
+  memoryPath(id, workspace) {
+    return join2(workspace ? this.workspaceDirectory(workspace) : this.globalsDirectory, `${id}${MARKDOWN_EXTENSION}`);
+  }
+  workspaceDirectory(workspace) {
+    return join2(this.workspacesDirectory, encodeWorkspaceSegment(workspace));
+  }
+  async writeFileAtomically(filePath, content, updatedAt) {
+    const directoryPath = dirname(filePath);
+    await mkdir(directoryPath, { recursive: true });
+    const tempPath = join2(directoryPath, `.${basename(filePath)}.${randomUUID()}.tmp`);
+    try {
+      await writeFile(tempPath, content, "utf8");
+      await rename(tempPath, filePath);
+      await utimes(filePath, updatedAt, updatedAt);
+    } catch (error2) {
+      await rm(tempPath, { force: true });
+      throw error2;
+    }
+  }
+  async cleanupWorkspaceDirectory(workspace) {
+    if (!workspace) {
+      return;
+    }
+    const directoryPath = this.workspaceDirectory(workspace);
+    const entries = await readDirectory(directoryPath);
+    if (entries.length === 0) {
+      await rm(directoryPath, { recursive: true, force: true });
+    }
+  }
+}
+function encodeWorkspaceSegment(workspace) {
+  return encodeURIComponent(workspace);
+}
+function decodeWorkspaceSegment(segment) {
+  return decodeURIComponent(segment);
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readDirectory(path) {
+  try {
+    return await readdir(path, { withFileTypes: true });
+  } catch (error2) {
+    if (isMissingPathError(error2)) {
+      return [];
+    }
+    throw error2;
+  }
+}
+function isMissingPathError(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
+}
+function asPersistenceError(message, error2) {
+  if (error2 instanceof NotFoundError || error2 instanceof PersistenceError) {
+    return error2;
+  }
+  return new PersistenceError(message, { cause: error2 });
+}
 // node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
@@ -17974,6 +18212,10 @@ class Protocol {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
       controller.abort();
     }
@@ -18104,7 +18346,9 @@ class Protocol {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request.id);
+      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request.id);
+      }
     });
   }
   _onprogress(notification) {
@@ -19762,6 +20006,9 @@ class McpServer {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
+        if (Object.values(firstArg).some((v) => typeof v === "object" && v !== null)) {
+          throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
+        }
         annotations = rest.shift();
       }
     }
@@ -19854,6 +20101,9 @@ function getZodSchemaObject(schema) {
   if (isZodRawShapeCompat(schema)) {
     return objectFromShape(schema);
   }
+  if (!isZodSchemaInstance(schema)) {
+    throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
+  }
   return schema;
 }
 function promptArgumentsFromSchema(schema) {
@@ -19898,37 +20148,6 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// src/errors.ts
-class MemoryError extends Error {
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.name = "MemoryError";
-    this.code = code;
-  }
-}
-
-class ValidationError extends MemoryError {
-  constructor(message) {
-    super("VALIDATION_ERROR", message);
-    this.name = "ValidationError";
-  }
-}
-
-class NotFoundError extends MemoryError {
-  constructor(message) {
-    super("NOT_FOUND", message);
-    this.name = "NotFoundError";
-  }
-}
-
-class PersistenceError extends MemoryError {
-  constructor(message, options) {
-    super("PERSISTENCE_ERROR", message, options);
-    this.name = "PersistenceError";
-  }
-}
-
 // src/mcp/tools/shared.ts
 function toMcpError(error2) {
   if (error2 instanceof McpError) {
@@ -19944,6 +20163,27 @@ function toMcpError(error2) {
   return new McpError(ErrorCode.InternalError, message);
 }
 var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function toMemoryXml(record3, options) {
+  const scopeAttribute = getMemoryScopeAttribute(record3, options?.skipWorkspaceIfEquals);
+  const attributes = [
+    `id="${escapeXml(record3.id)}"`,
+    `updated_at="${record3.updatedAt.toISOString()}"`,
+    scopeAttribute,
+    options?.deleted ? 'deleted="true"' : undefined
+  ].filter((value) => value).join(" ");
+  return `<memory ${attributes}>
+${escapeXml(record3.content)}
+</memory>`;
+}
+function getMemoryScopeAttribute(record3, skipWorkspaceIfEquals) {
+  if (record3.workspace === undefined) {
+    return 'global="true"';
+  }
+  if (record3.workspace === skipWorkspaceIfEquals) {
+    return;
+  }
+  return `workspace="${escapeXml(record3.workspace)}"`;
+}
 
 // src/mcp/tools/forget.ts
 var forgetInputSchema = {
@@ -19957,13 +20197,13 @@ function registerForgetTool(server, memory) {
       idempotentHint: true,
       openWorldHint: false
     },
-    description: 'Delete a memory that is wrong or obsolete. Use after `review` when you have the memory id. Use `revise` instead if the fact should remain with corrected wording. Returns `<memory id="..." deleted="true" />`.',
+    description: 'Delete a memory that is wrong or obsolete. Use after `review` when you have the memory id. Use `revise` instead if the fact should remain with corrected wording. Returns the deleted memory as `<memory ... deleted="true">...</memory>`.',
     inputSchema: forgetInputSchema
   }, async ({ id }) => {
     try {
-      await memory.delete({ id });
+      const deletedMemory = await memory.delete({ id });
       return {
-        content: [{ type: "text", text: `<memory id="${id.trim()}" deleted="true" />` }]
+        content: [{ type: "text", text: toMemoryXml(deletedMemory, { deleted: true }) }]
       };
     } catch (error2) {
       throw toMcpError(error2);
@@ -19984,7 +20224,7 @@ function registerRememberTool(server, memory) {
       idempotentHint: false,
       openWorldHint: false
     },
-    description: 'Save one new durable fact. Use for stable preferences, reusable decisions, and project context not obvious from code or git history. If the fact already exists, use `revise` instead. Returns `<memory id="..." />`.',
+    description: "Save one new durable fact. Use for stable preferences, reusable decisions, and project context not obvious from code or git history. If the fact already exists, use `revise` instead. Returns the saved memory as `<memory ...>...</memory>`.",
     inputSchema: rememberInputSchema
   }, async ({ content, workspace }) => {
     try {
@@ -19993,7 +20233,7 @@ function registerRememberTool(server, memory) {
         workspace
       });
       return {
-        content: [{ type: "text", text: `<memory id="${savedMemory.id}" />` }]
+        content: [{ type: "text", text: toMemoryXml(savedMemory) }]
       };
     } catch (error2) {
       throw toMcpError(error2);
@@ -20007,13 +20247,6 @@ var reviewInputSchema = {
   workspace: string2().describe("Current working directory for project-scoped listing."),
   page: number2().int().min(0).optional().describe("Zero-based page number. Defaults to 0.")
 };
-function toMemoryXml(record3, workspace) {
-  const global2 = record3.workspace !== workspace ? ' global="true"' : "";
-  const content = escapeXml(record3.content);
-  return `<memory id="${record3.id}"${global2} updated_at="${record3.updatedAt.toISOString()}">
-${content}
-</memory>`;
-}
 function registerReviewTool(server, memory) {
   server.registerTool("review", {
     annotations: {
@@ -20038,7 +20271,7 @@ function registerReviewTool(server, memory) {
         };
       }
       const escapedWorkspace = escapeXml(workspace);
-      const memories = result.items.map((item) => toMemoryXml(item, workspace)).join(`
+      const memories = result.items.map((item) => toMemoryXml(item, { skipWorkspaceIfEquals: workspace })).join(`
 `);
       const text = `<memories workspace="${escapedWorkspace}" has_more="${result.hasMore}">
 ${memories}
@@ -20055,7 +20288,8 @@ ${memories}
 // src/mcp/tools/revise.ts
 var reviseInputSchema = {
   id: string2().describe("Memory id to update. Use an id returned by `review`."),
-  content: string2().describe("Corrected replacement text for that memory.")
+  content: string2().optional().describe("Corrected replacement text for that memory. Omit to keep the current content."),
+  global: boolean2().optional().describe("Set to true to move a project-scoped memory to global scope.")
 };
 function registerReviseTool(server, memory) {
   server.registerTool("revise", {
@@ -20065,16 +20299,23 @@ function registerReviseTool(server, memory) {
       idempotentHint: false,
       openWorldHint: false
     },
-    description: 'Update one existing memory when the same fact still applies but its wording or details changed. Use after `review` when you already have the memory id. Returns `<memory id="..." updated_at="..." />`.',
+    description: "Update one existing memory when the same fact still applies but its wording changed, or when a project-scoped memory should become global. Use after `review` when you already have the memory id. Omit fields you do not want to change. Returns the revised memory as `<memory ...>...</memory>`.",
     inputSchema: reviseInputSchema
-  }, async ({ id, content }) => {
+  }, async ({ id, content, global }) => {
     try {
-      const revisedMemory = await memory.update({ id, content });
+      if (content === undefined && global !== true) {
+        throw new ValidationError("Provide at least one field to revise.");
+      }
+      const revisedMemory = await memory.update({
+        id,
+        content,
+        workspace: global === true ? null : undefined
+      });
       return {
         content: [
           {
             type: "text",
-            text: `<memory id="${revisedMemory.id}" updated_at="${revisedMemory.updatedAt.toISOString()}" />`
+            text: toMemoryXml(revisedMemory)
           }
         ]
       };
@@ -20088,7 +20329,7 @@ function registerReviseTool(server, memory) {
 var SERVER_INSTRUCTIONS = [
   "Durable memory for stable preferences, corrections, reusable decisions, and project context not obvious from code or git history.",
   "Workflow: (1) Call `review` with the current workspace at conversation start -- this loads workspace and global memories into context.",
-  "(2) During the session, call `remember` to save a new fact, `revise` to correct an existing one, or `forget` to remove one that is wrong or obsolete.",
+  "(2) During the session, call `remember` to save a new fact, `revise` to correct content or promote a project-scoped memory to global scope, and call `forget` to remove one that is wrong or obsolete.",
   "Always check loaded memories before calling `remember` to avoid duplicates -- use `revise` instead when the fact already exists.",
   "Pass workspace on `remember` for project-scoped memory. Omit it only for facts that apply across all projects.",
   "Never store secrets, temporary task state, or facts obvious from current code or git history."
@@ -20108,14 +20349,14 @@ function createMcpServer(memory, version3) {
 }
 
 // src/memory-service.ts
-var DEFAULT_LIST_LIMIT = 15;
+var DEFAULT_LIST_LIMIT2 = 15;
 var MAX_LIST_LIMIT = 100;
 
 class MemoryService {
   repository;
   workspaceResolver;
-  constructor(repository, workspaceResolver) {
-    this.repository = repository;
+  constructor(repository2, workspaceResolver) {
+    this.repository = repository2;
     this.workspaceResolver = workspaceResolver;
   }
   async create(input) {
@@ -20123,27 +20364,31 @@ class MemoryService {
     if (!content) {
       throw new ValidationError("Memory content is required.");
     }
-    const workspace = await this.workspaceResolver.resolve(input.workspace);
+    const workspace = await this.normalizeWorkspaceInput(input.workspace);
     return this.repository.create({ content, workspace });
   }
   async update(input) {
-    const content = input.content.trim();
-    if (!content)
-      throw new ValidationError("Memory content is required.");
-    return this.repository.update({ id: input.id, content });
+    const content = this.normalizeUpdateContent(input.content);
+    const workspace = await this.normalizeUpdateWorkspace(input.workspace);
+    return this.repository.update({ id: input.id, content, workspace });
   }
   async delete(input) {
     const id = input.id.trim();
     if (!id)
       throw new ValidationError("Memory id is required.");
-    return this.repository.delete({ id });
+    const existingMemory = await this.repository.get(id);
+    if (!existingMemory) {
+      throw new NotFoundError(`Memory not found: ${id}`);
+    }
+    await this.repository.delete({ id });
+    return existingMemory;
   }
   async get(id) {
     return this.repository.get(id);
   }
   async list(input) {
-    const queryWorkspace = normalizeOptionalString(input.workspace);
-    const workspace = await this.workspaceResolver.resolve(input.workspace);
+    const queryWorkspace = input.workspace?.trim() || undefined;
+    const workspace = queryWorkspace ? await this.workspaceResolver.resolve(queryWorkspace) : undefined;
     const page = await this.repository.list({
       workspace,
       global: input.global,
@@ -20158,20 +20403,42 @@ class MemoryService {
   async listWorkspaces() {
     return this.repository.listWorkspaces();
   }
+  normalizeUpdateContent(value) {
+    if (value === undefined) {
+      return;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new ValidationError("Memory content is required.");
+    }
+    return trimmed;
+  }
+  async normalizeUpdateWorkspace(value) {
+    if (value === undefined || value === null) {
+      return value;
+    }
+    return this.normalizeWorkspaceInput(value);
+  }
+  async normalizeWorkspaceInput(value) {
+    if (value === undefined) {
+      return;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new ValidationError("Workspace is required.");
+    }
+    return this.workspaceResolver.resolve(trimmed);
+  }
 }
 function normalizeOffset(value) {
   return Number.isInteger(value) && value && value > 0 ? value : 0;
 }
 function normalizeListLimit(value) {
   if (!Number.isInteger(value) || value === undefined) {
-    return DEFAULT_LIST_LIMIT;
+    return DEFAULT_LIST_LIMIT2;
   }
   return Math.min(Math.max(value, 1), MAX_LIST_LIMIT);
 }
-function normalizeOptionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
 function remapWorkspace(record3, canonicalWorkspace, queryWorkspace) {
   if (record3.workspace !== canonicalWorkspace) {
     return record3;
@@ -20179,3818 +20446,58 @@ function remapWorkspace(record3, canonicalWorkspace, queryWorkspace) {
   return { ...record3, workspace: queryWorkspace };
 }
 
-// src/sqlite/db.ts
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import Database from "better-sqlite3";
-
-// src/sqlite/memory-schema.ts
-function createMemoriesTable(database) {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id TEXT PRIMARY KEY,
-      content TEXT NOT NULL,
-      workspace TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-  `);
-}
-function createMemoryIndexes(database) {
-  database.exec(`
-    CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);
-    CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace);
-  `);
-}
-function createMemorySearchArtifacts(database, rebuild = false) {
-  database.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      content,
-      content = 'memories',
-      content_rowid = 'rowid',
-      tokenize = 'porter unicode61'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content)
-      VALUES ('delete', old.rowid, old.content);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content)
-      VALUES ('delete', old.rowid, old.content);
-      INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
-    END;
-  `);
-  if (rebuild) {
-    database.exec("INSERT INTO memories_fts(memories_fts) VALUES ('rebuild')");
-  }
-}
-function dropMemorySearchArtifacts(database) {
-  database.exec(`
-    DROP TRIGGER IF EXISTS memories_ai;
-    DROP TRIGGER IF EXISTS memories_ad;
-    DROP TRIGGER IF EXISTS memories_au;
-    DROP TABLE IF EXISTS memories_fts;
-  `);
-}
-
-// src/sqlite/migrations/001-create-memory-schema.ts
-var createMemorySchemaMigration = {
-  version: 1,
-  async up(database) {
-    createMemoriesTable(database);
-    createMemoryIndexes(database);
-    createMemorySearchArtifacts(database);
-  }
-};
-
-// src/sqlite/migrations/002-add-memory-embedding.ts
-function createAddMemoryEmbeddingMigration() {
-  return {
-    version: 2,
-    async up(database) {
-      database.exec("ALTER TABLE memories ADD COLUMN embedding BLOB");
-      dropMemorySearchArtifacts(database);
-      database.exec("ALTER TABLE memories RENAME TO memories_old");
-      database.exec(`
-        CREATE TABLE IF NOT EXISTS memories (
-          id TEXT PRIMARY KEY,
-          content TEXT NOT NULL,
-          workspace TEXT,
-          embedding BLOB NOT NULL,
-          created_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL
-        );
-      `);
-      database.exec(`
-        INSERT INTO memories (id, content, workspace, embedding, created_at, updated_at)
-        SELECT id, content, workspace, COALESCE(embedding, X'00000000'), created_at, updated_at
-        FROM memories_old
-      `);
-      database.exec("DROP TABLE memories_old");
-      createMemoryIndexes(database);
-      createMemorySearchArtifacts(database, true);
-    }
-  };
-}
-
-// src/sqlite/migrations/003-normalize-workspaces.ts
-function createNormalizeWorkspaceMigration(workspaceResolver) {
+// src/workspace-resolver.ts
+import { execFile } from "node:child_process";
+import { basename as basename2, dirname as dirname2 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+function createGitWorkspaceResolver(options = {}) {
+  const getGitCommonDir = options.getGitCommonDir ?? defaultGetGitCommonDir;
+  const cache = new Map;
   return {
-    version: 3,
-    async up(database) {
-      const rows = database.prepare("SELECT DISTINCT workspace FROM memories WHERE workspace IS NOT NULL ORDER BY workspace").all();
-      const updateStatement = database.prepare("UPDATE memories SET workspace = ? WHERE workspace = ?");
-      for (const row of rows) {
-        const normalizedWorkspace = await workspaceResolver.resolve(row.workspace);
-        if (!normalizedWorkspace || normalizedWorkspace === row.workspace) {
-          continue;
-        }
-        updateStatement.run(normalizedWorkspace, row.workspace);
+    async resolve(workspace) {
+      const trimmed = workspace.trim();
+      if (!trimmed) {
+        throw new ValidationError("Workspace is required.");
+      }
+      const cached2 = cache.get(trimmed);
+      if (cached2) {
+        return cached2;
       }
+      const pending = resolveWorkspace(trimmed, getGitCommonDir);
+      cache.set(trimmed, pending);
+      return pending;
     }
   };
 }
-
-// src/sqlite/migrations/004-remove-memory-embedding.ts
-var removeMemoryEmbeddingMigration = {
-  version: 4,
-  async up(database) {
-    dropMemorySearchArtifacts(database);
-    database.exec("ALTER TABLE memories RENAME TO memories_old");
-    createMemoriesTable(database);
-    database.exec(`
-      INSERT INTO memories (id, content, workspace, created_at, updated_at)
-      SELECT id, content, workspace, created_at, updated_at
-      FROM memories_old
-    `);
-    database.exec("DROP TABLE memories_old");
-    createMemoryIndexes(database);
-    createMemorySearchArtifacts(database, true);
-  }
-};
-
-// src/sqlite/migrations/index.ts
-function createMemoryMigrations(options) {
-  return [
-    createMemorySchemaMigration,
-    createAddMemoryEmbeddingMigration(),
-    createNormalizeWorkspaceMigration(options.workspaceResolver),
-    removeMemoryEmbeddingMigration
-  ];
-}
-
-// src/sqlite/db.ts
-var PRAGMA_STATEMENTS = [
-  "journal_mode = WAL",
-  "synchronous = NORMAL",
-  "foreign_keys = ON",
-  "busy_timeout = 5000"
-];
-async function openMemoryDatabase(databasePath, options) {
-  let database;
+async function resolveWorkspace(workspace, getGitCommonDir) {
   try {
-    mkdirSync(dirname(databasePath), { recursive: true });
-    database = new Database(databasePath);
-    await initializeMemoryDatabase(database, createMemoryMigrations(options));
-    return database;
-  } catch (error2) {
-    database?.close();
-    if (error2 instanceof PersistenceError) {
-      throw error2;
+    const gitCommonDir = (await getGitCommonDir(workspace)).trim();
+    if (basename2(gitCommonDir) !== ".git") {
+      return workspace;
     }
-    throw new PersistenceError("Failed to initialize the SQLite database.", {
-      cause: error2
-    });
+    return dirname2(gitCommonDir);
+  } catch {
+    return workspace;
   }
 }
-async function initializeMemoryDatabase(database, migrations) {
-  try {
-    applyPragmas(database);
-    await runSqliteMigrations(database, migrations);
-  } catch (error2) {
-    throw new PersistenceError("Failed to initialize the SQLite database.", {
-      cause: error2
-    });
-  }
-}
-async function runSqliteMigrations(database, migrations) {
-  validateMigrations(migrations);
-  let currentVersion = getUserVersion(database);
-  for (const migration of migrations) {
-    if (migration.version <= currentVersion) {
-      continue;
-    }
-    database.exec("BEGIN");
-    try {
-      await migration.up(database);
-      setUserVersion(database, migration.version);
-      database.exec("COMMIT");
-      currentVersion = migration.version;
-    } catch (error2) {
-      try {
-        database.exec("ROLLBACK");
-      } catch {}
-      throw error2;
-    }
-  }
-}
-function applyPragmas(database) {
-  if (database.pragma) {
-    for (const statement of PRAGMA_STATEMENTS) {
-      database.pragma(statement);
-    }
-    return;
-  }
-  for (const statement of PRAGMA_STATEMENTS) {
-    database.exec(`PRAGMA ${statement}`);
-  }
-}
-function getUserVersion(database) {
-  const rows = database.prepare("PRAGMA user_version").all();
-  return rows[0]?.user_version ?? 0;
-}
-function setUserVersion(database, version3) {
-  database.exec(`PRAGMA user_version = ${version3}`);
-}
-function validateMigrations(migrations) {
-  let previousVersion = 0;
-  for (const migration of migrations) {
-    if (!Number.isInteger(migration.version) || migration.version <= previousVersion) {
-      throw new Error("SQLite migrations must use strictly increasing versions.");
-    }
-    previousVersion = migration.version;
-  }
-}
-// src/sqlite/repository.ts
-import { randomUUID } from "node:crypto";
-var DEFAULT_LIST_LIMIT2 = 15;
-
-class SqliteMemoryRepository {
-  database;
-  insertStatement;
-  getStatement;
-  updateStatement;
-  deleteStatement;
-  listWorkspacesStatement;
-  constructor(database) {
-    this.database = database;
-    this.insertStatement = database.prepare(`
-      INSERT INTO memories (id, content, workspace, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-    this.getStatement = database.prepare("SELECT id, content, workspace, created_at, updated_at FROM memories WHERE id = ?");
-    this.updateStatement = database.prepare("UPDATE memories SET content = ?, updated_at = ? WHERE id = ?");
-    this.deleteStatement = database.prepare("DELETE FROM memories WHERE id = ?");
-    this.listWorkspacesStatement = database.prepare("SELECT DISTINCT workspace FROM memories WHERE workspace IS NOT NULL ORDER BY workspace");
-  }
-  async create(input) {
-    try {
-      const now = new Date;
-      const memory = {
-        id: randomUUID(),
-        content: input.content,
-        workspace: input.workspace,
-        createdAt: now,
-        updatedAt: now
-      };
-      this.insertStatement.run(memory.id, memory.content, memory.workspace, memory.createdAt.getTime(), memory.updatedAt.getTime());
-      return memory;
-    } catch (error2) {
-      throw new PersistenceError("Failed to save memory.", { cause: error2 });
-    }
-  }
-  async get(id) {
-    try {
-      const rows = this.getStatement.all(id);
-      const row = rows[0];
-      return row ? toMemoryRecord(row) : undefined;
-    } catch (error2) {
-      throw new PersistenceError("Failed to find memory.", { cause: error2 });
-    }
-  }
-  async list(options) {
-    try {
-      const whereClauses = [];
-      const params = [];
-      const offset = options.offset ?? 0;
-      const limit = options.limit ?? DEFAULT_LIST_LIMIT2;
-      if (options.workspace && options.global) {
-        whereClauses.push("(workspace = ? OR workspace IS NULL)");
-        params.push(options.workspace);
-      } else if (options.workspace) {
-        whereClauses.push("workspace = ?");
-        params.push(options.workspace);
-      } else if (options.global) {
-        whereClauses.push("workspace IS NULL");
-      }
-      const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-      const queryLimit = limit + 1;
-      params.push(queryLimit, offset);
-      const statement = this.database.prepare(`
-        SELECT id, content, workspace, created_at, updated_at
-        FROM memories
-        ${whereClause}
-        ORDER BY updated_at DESC
-        LIMIT ? OFFSET ?
-      `);
-      const rows = statement.all(...params);
-      const hasMore = rows.length > limit;
-      const items = (hasMore ? rows.slice(0, limit) : rows).map(toMemoryRecord);
-      return { items, hasMore };
-    } catch (error2) {
-      throw new PersistenceError("Failed to list memories.", { cause: error2 });
-    }
-  }
-  async update(input) {
-    let result;
-    try {
-      const now = Date.now();
-      result = this.updateStatement.run(input.content, now, input.id);
-    } catch (error2) {
-      throw new PersistenceError("Failed to update memory.", { cause: error2 });
-    }
-    if (result.changes === 0) {
-      throw new NotFoundError(`Memory not found: ${input.id}`);
-    }
-    const memory = await this.get(input.id);
-    if (!memory) {
-      throw new NotFoundError(`Memory not found after update: ${input.id}`);
-    }
-    return memory;
-  }
-  async delete(input) {
-    let result;
-    try {
-      result = this.deleteStatement.run(input.id);
-    } catch (error2) {
-      throw new PersistenceError("Failed to delete memory.", { cause: error2 });
-    }
-    if (result.changes === 0) {
-      throw new NotFoundError(`Memory not found: ${input.id}`);
-    }
-  }
-  async listWorkspaces() {
-    try {
-      const rows = this.listWorkspacesStatement.all();
-      return rows.map((row) => row.workspace);
-    } catch (error2) {
-      throw new PersistenceError("Failed to list workspaces.", { cause: error2 });
-    }
-  }
-}
-var toMemoryRecord = (row) => ({
-  id: row.id,
-  content: row.content,
-  workspace: row.workspace ?? undefined,
-  createdAt: new Date(row.created_at),
-  updatedAt: new Date(row.updated_at)
-});
-// node_modules/@hono/node-server/dist/index.mjs
-import { createServer as createServerHTTP } from "http";
-import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
-import { Http2ServerRequest } from "http2";
-import { Readable } from "stream";
-import crypto from "crypto";
-var RequestError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "RequestError";
-  }
-};
-var toRequestError = (e) => {
-  if (e instanceof RequestError) {
-    return e;
-  }
-  return new RequestError(e.message, { cause: e });
-};
-var GlobalRequest = global.Request;
-var Request2 = class extends GlobalRequest {
-  constructor(input, options) {
-    if (typeof input === "object" && getRequestCache in input) {
-      input = input[getRequestCache]();
-    }
-    if (typeof options?.body?.getReader !== "undefined") {
-      options.duplex ??= "half";
-    }
-    super(input, options);
-  }
-};
-var newHeadersFromIncoming = (incoming) => {
-  const headerRecord = [];
-  const rawHeaders = incoming.rawHeaders;
-  for (let i = 0;i < rawHeaders.length; i += 2) {
-    const { [i]: key, [i + 1]: value } = rawHeaders;
-    if (key.charCodeAt(0) !== 58) {
-      headerRecord.push([key, value]);
-    }
-  }
-  return new Headers(headerRecord);
-};
-var wrapBodyStream = Symbol("wrapBodyStream");
-var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
-  const init = {
-    method,
-    headers,
-    signal: abortController.signal
-  };
-  if (method === "TRACE") {
-    init.method = "GET";
-    const req = new Request2(url, init);
-    Object.defineProperty(req, "method", {
-      get() {
-        return "TRACE";
-      }
-    });
-    return req;
-  }
-  if (!(method === "GET" || method === "HEAD")) {
-    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
-      init.body = new ReadableStream({
-        start(controller) {
-          controller.enqueue(incoming.rawBody);
-          controller.close();
-        }
-      });
-    } else if (incoming[wrapBodyStream]) {
-      let reader;
-      init.body = new ReadableStream({
-        async pull(controller) {
-          try {
-            reader ||= Readable.toWeb(incoming).getReader();
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-            } else {
-              controller.enqueue(value);
-            }
-          } catch (error2) {
-            controller.error(error2);
-          }
-        }
-      });
-    } else {
-      init.body = Readable.toWeb(incoming);
-    }
-  }
-  return new Request2(url, init);
-};
-var getRequestCache = Symbol("getRequestCache");
-var requestCache = Symbol("requestCache");
-var incomingKey = Symbol("incomingKey");
-var urlKey = Symbol("urlKey");
-var headersKey = Symbol("headersKey");
-var abortControllerKey = Symbol("abortControllerKey");
-var getAbortController = Symbol("getAbortController");
-var requestPrototype = {
-  get method() {
-    return this[incomingKey].method || "GET";
-  },
-  get url() {
-    return this[urlKey];
-  },
-  get headers() {
-    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
-  },
-  [getAbortController]() {
-    this[getRequestCache]();
-    return this[abortControllerKey];
-  },
-  [getRequestCache]() {
-    this[abortControllerKey] ||= new AbortController;
-    return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "cache",
-  "credentials",
-  "destination",
-  "integrity",
-  "mode",
-  "redirect",
-  "referrer",
-  "referrerPolicy",
-  "signal",
-  "keepalive"
-].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    get() {
-      return this[getRequestCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    value: function() {
-      return this[getRequestCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(requestPrototype, Request2.prototype);
-var newRequest = (incoming, defaultHostname) => {
-  const req = Object.create(requestPrototype);
-  req[incomingKey] = incoming;
-  const incomingUrl = incoming.url || "";
-  if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-    if (incoming instanceof Http2ServerRequest) {
-      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
-    }
-    try {
-      const url2 = new URL(incomingUrl);
-      req[urlKey] = url2.href;
-    } catch (e) {
-      throw new RequestError("Invalid absolute URL", { cause: e });
-    }
-    return req;
-  }
-  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
-    throw new RequestError("Missing host header");
-  }
-  let scheme;
-  if (incoming instanceof Http2ServerRequest) {
-    scheme = incoming.scheme;
-    if (!(scheme === "http" || scheme === "https")) {
-      throw new RequestError("Unsupported scheme");
-    }
-  } else {
-    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
-  }
-  const url = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
-    throw new RequestError("Invalid host header");
-  }
-  req[urlKey] = url.href;
-  return req;
-};
-var responseCache = Symbol("responseCache");
-var getResponseCache = Symbol("getResponseCache");
-var cacheKey = Symbol("cache");
-var GlobalResponse = global.Response;
-var Response2 = class _Response {
-  #body;
-  #init;
-  [getResponseCache]() {
-    delete this[cacheKey];
-    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-  }
-  constructor(body, init) {
-    let headers;
-    this.#body = body;
-    if (init instanceof _Response) {
-      const cachedGlobalResponse = init[responseCache];
-      if (cachedGlobalResponse) {
-        this.#init = cachedGlobalResponse;
-        this[getResponseCache]();
-        return;
-      } else {
-        this.#init = init.#init;
-        headers = new Headers(init.#init.headers);
-      }
-    } else {
-      this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
-      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
-    }
-  }
-  get headers() {
-    const cache = this[cacheKey];
-    if (cache) {
-      if (!(cache[2] instanceof Headers)) {
-        cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
-      }
-      return cache[2];
-    }
-    return this[getResponseCache]().headers;
-  }
-  get status() {
-    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
-  }
-  get ok() {
-    const status = this.status;
-    return status >= 200 && status < 300;
-  }
-};
-["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-async function readWithoutBlocking(readPromise) {
-  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
-}
-function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
-  const cancel = (error2) => {
-    reader.cancel(error2).catch(() => {});
-  };
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
-  return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
-  });
-  function handleStreamError(error2) {
-    if (error2) {
-      writable.destroy(error2);
-    }
-  }
-  function onDrain() {
-    reader.read().then(flow, handleStreamError);
-  }
-  function flow({ done, value }) {
-    try {
-      if (done) {
-        writable.end();
-      } else if (!writable.write(value)) {
-        writable.once("drain", onDrain);
-      } else {
-        return reader.read().then(flow, handleStreamError);
-      }
-    } catch (e) {
-      handleStreamError(e);
-    }
-  }
-}
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    return;
-  }
-  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
-}
-var buildOutgoingHttpHeaders = (headers) => {
-  const res = {};
-  if (!(headers instanceof Headers)) {
-    headers = new Headers(headers ?? undefined);
-  }
-  const cookies = [];
-  for (const [k, v] of headers) {
-    if (k === "set-cookie") {
-      cookies.push(v);
-    } else {
-      res[k] = v;
-    }
-  }
-  if (cookies.length > 0) {
-    res["set-cookie"] = cookies;
-  }
-  res["content-type"] ??= "text/plain; charset=UTF-8";
-  return res;
-};
-var X_ALREADY_SENT = "x-hono-already-sent";
-if (typeof global.crypto === "undefined") {
-  global.crypto = crypto;
-}
-var outgoingEnded = Symbol("outgoingEnded");
-var handleRequestError = () => new Response(null, {
-  status: 400
-});
-var handleFetchError = (e) => new Response(null, {
-  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
-});
-var handleResponseError = (e, outgoing) => {
-  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
-  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
-    console.info("The user aborted a request.");
-  } else {
-    console.error(e);
-    if (!outgoing.headersSent) {
-      outgoing.writeHead(500, { "Content-Type": "text/plain" });
-    }
-    outgoing.end(`Error: ${err.message}`);
-    outgoing.destroy(err);
-  }
-};
-var flushHeaders = (outgoing) => {
-  if ("flushHeaders" in outgoing && outgoing.writable) {
-    outgoing.flushHeaders();
-  }
-};
-var responseViaCache = async (res, outgoing) => {
-  let [status, body, header] = res[cacheKey];
-  let hasContentLength = false;
-  if (!header) {
-    header = { "content-type": "text/plain; charset=UTF-8" };
-  } else if (header instanceof Headers) {
-    hasContentLength = header.has("content-length");
-    header = buildOutgoingHttpHeaders(header);
-  } else if (Array.isArray(header)) {
-    const headerObj = new Headers(header);
-    hasContentLength = headerObj.has("content-length");
-    header = buildOutgoingHttpHeaders(headerObj);
-  } else {
-    for (const key in header) {
-      if (key.length === 14 && key.toLowerCase() === "content-length") {
-        hasContentLength = true;
-        break;
-      }
-    }
-  }
-  if (!hasContentLength) {
-    if (typeof body === "string") {
-      header["Content-Length"] = Buffer.byteLength(body);
-    } else if (body instanceof Uint8Array) {
-      header["Content-Length"] = body.byteLength;
-    } else if (body instanceof Blob) {
-      header["Content-Length"] = body.size;
-    }
-  }
-  outgoing.writeHead(status, header);
-  if (typeof body === "string" || body instanceof Uint8Array) {
-    outgoing.end(body);
-  } else if (body instanceof Blob) {
-    outgoing.end(new Uint8Array(await body.arrayBuffer()));
-  } else {
-    flushHeaders(outgoing);
-    await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
-  }
-  outgoing[outgoingEnded]?.();
-};
-var isPromise = (res) => typeof res.then === "function";
-var responseViaResponseObject = async (res, outgoing, options = {}) => {
-  if (isPromise(res)) {
-    if (options.errorHandler) {
-      try {
-        res = await res;
-      } catch (err) {
-        const errRes = await options.errorHandler(err);
-        if (!errRes) {
-          return;
-        }
-        res = errRes;
-      }
-    } else {
-      res = await res.catch(handleFetchError);
-    }
-  }
-  if (cacheKey in res) {
-    return responseViaCache(res, outgoing);
-  }
-  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  if (res.body) {
-    const reader = res.body.getReader();
-    const values = [];
-    let done = false;
-    let currentReadPromise = undefined;
-    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
-      let maxReadCount = 2;
-      for (let i = 0;i < maxReadCount; i++) {
-        currentReadPromise ||= reader.read();
-        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
-          console.error(e);
-          done = true;
-        });
-        if (!chunk) {
-          if (i === 1) {
-            await new Promise((resolve) => setTimeout(resolve));
-            maxReadCount = 3;
-            continue;
-          }
-          break;
-        }
-        currentReadPromise = undefined;
-        if (chunk.value) {
-          values.push(chunk.value);
-        }
-        if (chunk.done) {
-          done = true;
-          break;
-        }
-      }
-      if (done && !("content-length" in resHeaderRecord)) {
-        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
-      }
-    }
-    outgoing.writeHead(res.status, resHeaderRecord);
-    values.forEach((value) => {
-      outgoing.write(value);
-    });
-    if (done) {
-      outgoing.end();
-    } else {
-      if (values.length === 0) {
-        flushHeaders(outgoing);
-      }
-      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
-    }
-  } else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
-    outgoing.writeHead(res.status, resHeaderRecord);
-    outgoing.end();
-  }
-  outgoing[outgoingEnded]?.();
-};
-var getRequestListener = (fetchCallback, options = {}) => {
-  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
-    Object.defineProperty(global, "Request", {
-      value: Request2
-    });
-    Object.defineProperty(global, "Response", {
-      value: Response2
-    });
-  }
-  return async (incoming, outgoing) => {
-    let res, req;
-    try {
-      req = newRequest(incoming, options.hostname);
-      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-      if (!incomingEnded) {
-        incoming[wrapBodyStream] = true;
-        incoming.on("end", () => {
-          incomingEnded = true;
-        });
-        if (incoming instanceof Http2ServerRequest2) {
-          outgoing[outgoingEnded] = () => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                if (!incomingEnded) {
-                  setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
-                  });
-                }
-              });
-            }
-          };
-        }
-      }
-      outgoing.on("close", () => {
-        const abortController = req[abortControllerKey];
-        if (abortController) {
-          if (incoming.errored) {
-            req[abortControllerKey].abort(incoming.errored.toString());
-          } else if (!outgoing.writableFinished) {
-            req[abortControllerKey].abort("Client connection prematurely closed.");
-          }
-        }
-        if (!incomingEnded) {
-          setTimeout(() => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                incoming.destroy();
-              });
-            }
-          });
-        }
-      });
-      res = fetchCallback(req, { incoming, outgoing });
-      if (cacheKey in res) {
-        return responseViaCache(res, outgoing);
-      }
-    } catch (e) {
-      if (!res) {
-        if (options.errorHandler) {
-          res = await options.errorHandler(req ? e : toRequestError(e));
-          if (!res) {
-            return;
-          }
-        } else if (!req) {
-          res = handleRequestError();
-        } else {
-          res = handleFetchError(e);
-        }
-      } else {
-        return handleResponseError(e, outgoing);
-      }
-    }
-    try {
-      return await responseViaResponseObject(res, outgoing, options);
-    } catch (e) {
-      return handleResponseError(e, outgoing);
-    }
-  };
-};
-var createAdaptorServer = (options) => {
-  const fetchCallback = options.fetch;
-  const requestListener = getRequestListener(fetchCallback, {
-    hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects,
-    autoCleanupIncoming: options.autoCleanupIncoming
-  });
-  const createServer = options.createServer || createServerHTTP;
-  const server = createServer(options.serverOptions || {}, requestListener);
-  return server;
-};
-var serve = (options, listeningListener) => {
-  const server = createAdaptorServer(options);
-  server.listen(options?.port ?? 3000, options.hostname, () => {
-    const serverInfo = server.address();
-    listeningListener && listeningListener(serverInfo);
-  });
-  return server;
-};
-
-// node_modules/hono/dist/compose.js
-var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
-    let index = -1;
-    return dispatch(0);
-    async function dispatch(i) {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      let res;
-      let isError = false;
-      let handler;
-      if (middleware[i]) {
-        handler = middleware[i][0][0];
-        context.req.routeIndex = i;
-      } else {
-        handler = i === middleware.length && next || undefined;
-      }
-      if (handler) {
-        try {
-          res = await handler(context, () => dispatch(i + 1));
-        } catch (err) {
-          if (err instanceof Error && onError) {
-            context.error = err;
-            res = await onError(err, context);
-            isError = true;
-          } else {
-            throw err;
-          }
-        }
-      } else {
-        if (context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
-        }
-      }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
-      }
-      return context;
-    }
-  };
-};
-
-// node_modules/hono/dist/request/constants.js
-var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
-
-// node_modules/hono/dist/utils/body.js
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-  const { all = false, dot = false } = options;
-  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-  const contentType = headers.get("Content-Type");
-  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
-    return parseFormData(request, { all, dot });
-  }
-  return {};
-};
-async function parseFormData(request, options) {
-  const formData = await request.formData();
-  if (formData) {
-    return convertFormDataToBodyData(formData, options);
-  }
-  return {};
-}
-function convertFormDataToBodyData(formData, options) {
-  const form = /* @__PURE__ */ Object.create(null);
-  formData.forEach((value, key) => {
-    const shouldParseAllValues = options.all || key.endsWith("[]");
-    if (!shouldParseAllValues) {
-      form[key] = value;
-    } else {
-      handleParsingAllValues(form, key, value);
-    }
-  });
-  if (options.dot) {
-    Object.entries(form).forEach(([key, value]) => {
-      const shouldParseDotValues = key.includes(".");
-      if (shouldParseDotValues) {
-        handleParsingNestedValues(form, key, value);
-        delete form[key];
-      }
-    });
-  }
-  return form;
-}
-var handleParsingAllValues = (form, key, value) => {
-  if (form[key] !== undefined) {
-    if (Array.isArray(form[key])) {
-      form[key].push(value);
-    } else {
-      form[key] = [form[key], value];
-    }
-  } else {
-    if (!key.endsWith("[]")) {
-      form[key] = value;
-    } else {
-      form[key] = [value];
-    }
-  }
-};
-var handleParsingNestedValues = (form, key, value) => {
-  if (/(?:^|\.)__proto__\./.test(key)) {
-    return;
-  }
-  let nestedForm = form;
-  const keys = key.split(".");
-  keys.forEach((key2, index) => {
-    if (index === keys.length - 1) {
-      nestedForm[key2] = value;
-    } else {
-      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
-        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-      }
-      nestedForm = nestedForm[key2];
-    }
-  });
-};
-
-// node_modules/hono/dist/utils/url.js
-var splitPath = (path) => {
-  const paths = path.split("/");
-  if (paths[0] === "") {
-    paths.shift();
-  }
-  return paths;
-};
-var splitRoutingPath = (routePath) => {
-  const { groups, path } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path);
-  return replaceGroupMarks(paths, groups);
-};
-var extractGroupsFromPath = (path) => {
-  const groups = [];
-  path = path.replace(/\{[^}]+\}/g, (match, index) => {
-    const mark = `@${index}`;
-    groups.push([mark, match]);
-    return mark;
-  });
-  return { groups, path };
-};
-var replaceGroupMarks = (paths, groups) => {
-  for (let i = groups.length - 1;i >= 0; i--) {
-    const [mark] = groups[i];
-    for (let j = paths.length - 1;j >= 0; j--) {
-      if (paths[j].includes(mark)) {
-        paths[j] = paths[j].replace(mark, groups[i][1]);
-        break;
-      }
-    }
-  }
-  return paths;
-};
-var patternCache = {};
-var getPattern = (label, next) => {
-  if (label === "*") {
-    return "*";
-  }
-  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-  if (match) {
-    const cacheKey2 = `${label}#${next}`;
-    if (!patternCache[cacheKey2]) {
-      if (match[2]) {
-        patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
-      } else {
-        patternCache[cacheKey2] = [label, match[1], true];
-      }
-    }
-    return patternCache[cacheKey2];
-  }
-  return null;
-};
-var tryDecode = (str, decoder) => {
-  try {
-    return decoder(str);
-  } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-      try {
-        return decoder(match);
-      } catch {
-        return match;
-      }
-    });
-  }
-};
-var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var getPath = (request) => {
-  const url = request.url;
-  const start = url.indexOf("/", url.indexOf(":") + 4);
-  let i = start;
-  for (;i < url.length; i++) {
-    const charCode = url.charCodeAt(i);
-    if (charCode === 37) {
-      const queryIndex = url.indexOf("?", i);
-      const hashIndex = url.indexOf("#", i);
-      const end = queryIndex === -1 ? hashIndex === -1 ? undefined : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path = url.slice(start, end);
-      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
-    } else if (charCode === 63 || charCode === 35) {
-      break;
-    }
-  }
-  return url.slice(start, i);
-};
-var getPathNoStrict = (request) => {
-  const result = getPath(request);
-  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
-};
-var mergePath = (base, sub, ...rest) => {
-  if (rest.length) {
-    sub = mergePath(sub, ...rest);
-  }
-  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
-};
-var checkOptionalParameter = (path) => {
-  if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) {
-    return null;
-  }
-  const segments = path.split("/");
-  const results = [];
-  let basePath = "";
-  segments.forEach((segment) => {
-    if (segment !== "" && !/\:/.test(segment)) {
-      basePath += "/" + segment;
-    } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
-        if (results.length === 0 && basePath === "") {
-          results.push("/");
-        } else {
-          results.push(basePath);
-        }
-        const optionalSegment = segment.replace("?", "");
-        basePath += "/" + optionalSegment;
-        results.push(basePath);
-      } else {
-        basePath += "/" + segment;
-      }
-    }
-  });
-  return results.filter((v, i, a) => a.indexOf(v) === i);
-};
-var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
-  if (value.indexOf("+") !== -1) {
-    value = value.replace(/\+/g, " ");
-  }
-  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
-};
-var _getQueryParam = (url, key, multiple) => {
-  let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
-    let keyIndex2 = url.indexOf("?", 8);
-    if (keyIndex2 === -1) {
-      return;
-    }
-    if (!url.startsWith(key, keyIndex2 + 1)) {
-      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    while (keyIndex2 !== -1) {
-      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-      if (trailingKeyCode === 61) {
-        const valueIndex = keyIndex2 + key.length + 2;
-        const endIndex = url.indexOf("&", valueIndex);
-        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? undefined : endIndex));
-      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
-        return "";
-      }
-      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    encoded = /[%+]/.test(url);
-    if (!encoded) {
-      return;
-    }
-  }
-  const results = {};
-  encoded ??= /[%+]/.test(url);
-  let keyIndex = url.indexOf("?", 8);
-  while (keyIndex !== -1) {
-    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-    let valueIndex = url.indexOf("=", keyIndex);
-    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
-      valueIndex = -1;
-    }
-    let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
-    if (encoded) {
-      name = _decodeURI(name);
-    }
-    keyIndex = nextKeyIndex;
-    if (name === "") {
-      continue;
-    }
-    let value;
-    if (valueIndex === -1) {
-      value = "";
-    } else {
-      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
-      if (encoded) {
-        value = _decodeURI(value);
-      }
-    }
-    if (multiple) {
-      if (!(results[name] && Array.isArray(results[name]))) {
-        results[name] = [];
-      }
-      results[name].push(value);
-    } else {
-      results[name] ??= value;
-    }
-  }
-  return key ? results[key] : results;
-};
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url, key) => {
-  return _getQueryParam(url, key, true);
-};
-var decodeURIComponent_ = decodeURIComponent;
-
-// node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
-var HonoRequest = class {
-  raw;
-  #validatedData;
-  #matchResult;
-  routeIndex = 0;
-  path;
-  bodyCache = {};
-  constructor(request, path = "/", matchResult = [[]]) {
-    this.raw = request;
-    this.path = path;
-    this.#matchResult = matchResult;
-    this.#validatedData = {};
-  }
-  param(key) {
-    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
-  }
-  #getDecodedParam(key) {
-    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-    const param = this.#getParamValue(paramKey);
-    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
-  }
-  #getAllDecodedParams() {
-    const decoded = {};
-    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-    for (const key of keys) {
-      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-      if (value !== undefined) {
-        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
-      }
-    }
-    return decoded;
-  }
-  #getParamValue(paramKey) {
-    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-  }
-  query(key) {
-    return getQueryParam(this.url, key);
-  }
-  queries(key) {
-    return getQueryParams(this.url, key);
-  }
-  header(name) {
-    if (name) {
-      return this.raw.headers.get(name) ?? undefined;
-    }
-    const headerData = {};
-    this.raw.headers.forEach((value, key) => {
-      headerData[key] = value;
-    });
-    return headerData;
-  }
-  async parseBody(options) {
-    return this.bodyCache.parsedBody ??= await parseBody(this, options);
-  }
-  #cachedBody = (key) => {
-    const { bodyCache, raw } = this;
-    const cachedBody = bodyCache[key];
-    if (cachedBody) {
-      return cachedBody;
-    }
-    const anyCachedKey = Object.keys(bodyCache)[0];
-    if (anyCachedKey) {
-      return bodyCache[anyCachedKey].then((body) => {
-        if (anyCachedKey === "json") {
-          body = JSON.stringify(body);
-        }
-        return new Response(body)[key]();
-      });
-    }
-    return bodyCache[key] = raw[key]();
-  };
-  json() {
-    return this.#cachedBody("text").then((text) => JSON.parse(text));
-  }
-  text() {
-    return this.#cachedBody("text");
-  }
-  arrayBuffer() {
-    return this.#cachedBody("arrayBuffer");
-  }
-  blob() {
-    return this.#cachedBody("blob");
-  }
-  formData() {
-    return this.#cachedBody("formData");
-  }
-  addValidatedData(target, data) {
-    this.#validatedData[target] = data;
-  }
-  valid(target) {
-    return this.#validatedData[target];
-  }
-  get url() {
-    return this.raw.url;
-  }
-  get method() {
-    return this.raw.method;
-  }
-  get [GET_MATCH_RESULT]() {
-    return this.#matchResult;
-  }
-  get matchedRoutes() {
-    return this.#matchResult[0].map(([[, route]]) => route);
-  }
-  get routePath() {
-    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-  }
-};
-
-// node_modules/hono/dist/utils/html.js
-var HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3
-};
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
-};
-var escapeRe = /[&<>'"]/;
-var stringBufferToString = async (buffer, callbacks) => {
-  let str = "";
-  callbacks ||= [];
-  const resolvedBuffer = await Promise.all(buffer);
-  for (let i = resolvedBuffer.length - 1;; i--) {
-    str += resolvedBuffer[i];
-    i--;
-    if (i < 0) {
-      break;
-    }
-    let r = resolvedBuffer[i];
-    if (typeof r === "object") {
-      callbacks.push(...r.callbacks || []);
-    }
-    const isEscaped = r.isEscaped;
-    r = await (typeof r === "object" ? r.toString() : r);
-    if (typeof r === "object") {
-      callbacks.push(...r.callbacks || []);
-    }
-    if (r.isEscaped ?? isEscaped) {
-      str += r;
-    } else {
-      const buf = [str];
-      escapeToBuffer(r, buf);
-      str = buf[0];
-    }
-  }
-  return raw(str, callbacks);
-};
-var escapeToBuffer = (str, buffer) => {
-  const match = str.search(escapeRe);
-  if (match === -1) {
-    buffer[0] += str;
-    return;
-  }
-  let escape2;
-  let index;
-  let lastIndex = 0;
-  for (index = match;index < str.length; index++) {
-    switch (str.charCodeAt(index)) {
-      case 34:
-        escape2 = "&quot;";
-        break;
-      case 39:
-        escape2 = "&#39;";
-        break;
-      case 38:
-        escape2 = "&amp;";
-        break;
-      case 60:
-        escape2 = "&lt;";
-        break;
-      case 62:
-        escape2 = "&gt;";
-        break;
-      default:
-        continue;
-    }
-    buffer[0] += str.substring(lastIndex, index) + escape2;
-    lastIndex = index + 1;
-  }
-  buffer[0] += str.substring(lastIndex, index);
-};
-var resolveCallbackSync = (str) => {
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return str;
-  }
-  const buffer = [str];
-  const context = {};
-  callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }));
-  return buffer[0];
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-  if (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
-    }
-    if (str instanceof Promise) {
-      str = await str;
-    }
-  }
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return Promise.resolve(str);
-  }
-  if (buffer) {
-    buffer[0] += str;
-  } else {
-    buffer = [str];
-  }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
-  } else {
-    return resStr;
-  }
-};
-
-// node_modules/hono/dist/context.js
-var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setDefaultContentType = (contentType, headers) => {
-  return {
-    "Content-Type": contentType,
-    ...headers
-  };
-};
-var createResponseInstance = (body, init) => new Response(body, init);
-var Context = class {
-  #rawRequest;
-  #req;
-  env = {};
-  #var;
-  finalized = false;
-  error;
-  #status;
-  #executionCtx;
-  #res;
-  #layout;
-  #renderer;
-  #notFoundHandler;
-  #preparedHeaders;
-  #matchResult;
-  #path;
-  constructor(req, options) {
-    this.#rawRequest = req;
-    if (options) {
-      this.#executionCtx = options.executionCtx;
-      this.env = options.env;
-      this.#notFoundHandler = options.notFoundHandler;
-      this.#path = options.path;
-      this.#matchResult = options.matchResult;
-    }
-  }
-  get req() {
-    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
-    return this.#req;
-  }
-  get event() {
-    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no FetchEvent");
-    }
-  }
-  get executionCtx() {
-    if (this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no ExecutionContext");
-    }
-  }
-  get res() {
-    return this.#res ||= createResponseInstance(null, {
-      headers: this.#preparedHeaders ??= new Headers
-    });
-  }
-  set res(_res) {
-    if (this.#res && _res) {
-      _res = createResponseInstance(_res.body, _res);
-      for (const [k, v] of this.#res.headers.entries()) {
-        if (k === "content-type") {
-          continue;
-        }
-        if (k === "set-cookie") {
-          const cookies = this.#res.headers.getSetCookie();
-          _res.headers.delete("set-cookie");
-          for (const cookie of cookies) {
-            _res.headers.append("set-cookie", cookie);
-          }
-        } else {
-          _res.headers.set(k, v);
-        }
-      }
-    }
-    this.#res = _res;
-    this.finalized = true;
-  }
-  render = (...args) => {
-    this.#renderer ??= (content) => this.html(content);
-    return this.#renderer(...args);
-  };
-  setLayout = (layout) => this.#layout = layout;
-  getLayout = () => this.#layout;
-  setRenderer = (renderer) => {
-    this.#renderer = renderer;
-  };
-  header = (name, value, options) => {
-    if (this.finalized) {
-      this.#res = createResponseInstance(this.#res.body, this.#res);
-    }
-    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers;
-    if (value === undefined) {
-      headers.delete(name);
-    } else if (options?.append) {
-      headers.append(name, value);
-    } else {
-      headers.set(name, value);
-    }
-  };
-  status = (status) => {
-    this.#status = status;
-  };
-  set = (key, value) => {
-    this.#var ??= /* @__PURE__ */ new Map;
-    this.#var.set(key, value);
-  };
-  get = (key) => {
-    return this.#var ? this.#var.get(key) : undefined;
-  };
-  get var() {
-    if (!this.#var) {
-      return {};
-    }
-    return Object.fromEntries(this.#var);
-  }
-  #newResponse(data, arg, headers) {
-    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers;
-    if (typeof arg === "object" && "headers" in arg) {
-      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-      for (const [key, value] of argHeaders) {
-        if (key.toLowerCase() === "set-cookie") {
-          responseHeaders.append(key, value);
-        } else {
-          responseHeaders.set(key, value);
-        }
-      }
-    }
-    if (headers) {
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          responseHeaders.set(k, v);
-        } else {
-          responseHeaders.delete(k);
-          for (const v2 of v) {
-            responseHeaders.append(k, v2);
-          }
-        }
-      }
-    }
-    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-    return createResponseInstance(data, { status, headers: responseHeaders });
-  }
-  newResponse = (...args) => this.#newResponse(...args);
-  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
-  text = (text, arg, headers) => {
-    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
-  };
-  json = (object4, arg, headers) => {
-    return this.#newResponse(JSON.stringify(object4), arg, setDefaultContentType("application/json", headers));
-  };
-  html = (html, arg, headers) => {
-    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
-    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
-  };
-  redirect = (location, status) => {
-    const locationString = String(location);
-    this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
-    return this.newResponse(null, status ?? 302);
-  };
-  notFound = () => {
-    this.#notFoundHandler ??= () => createResponseInstance();
-    return this.#notFoundHandler(this);
-  };
-};
-
-// node_modules/hono/dist/router.js
-var METHOD_NAME_ALL = "ALL";
-var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {
-};
-
-// node_modules/hono/dist/utils/constants.js
-var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
-
-// node_modules/hono/dist/hono-base.js
-var notFoundHandler = (c) => {
-  return c.text("404 Not Found", 404);
-};
-var errorHandler = (err, c) => {
-  if ("getResponse" in err) {
-    const res = err.getResponse();
-    return c.newResponse(res.body, res);
-  }
-  console.error(err);
-  return c.text("Internal Server Error", 500);
-};
-var Hono = class _Hono {
-  get;
-  post;
-  put;
-  delete;
-  options;
-  patch;
-  all;
-  on;
-  use;
-  router;
-  getPath;
-  _basePath = "/";
-  #path = "/";
-  routes = [];
-  constructor(options = {}) {
-    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
-    allMethods.forEach((method) => {
-      this[method] = (args1, ...args) => {
-        if (typeof args1 === "string") {
-          this.#path = args1;
-        } else {
-          this.#addRoute(method, this.#path, args1);
-        }
-        args.forEach((handler) => {
-          this.#addRoute(method, this.#path, handler);
-        });
-        return this;
-      };
-    });
-    this.on = (method, path, ...handlers) => {
-      for (const p of [path].flat()) {
-        this.#path = p;
-        for (const m of [method].flat()) {
-          handlers.map((handler) => {
-            this.#addRoute(m.toUpperCase(), this.#path, handler);
-          });
-        }
-      }
-      return this;
-    };
-    this.use = (arg1, ...handlers) => {
-      if (typeof arg1 === "string") {
-        this.#path = arg1;
-      } else {
-        this.#path = "*";
-        handlers.unshift(arg1);
-      }
-      handlers.forEach((handler) => {
-        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
-      });
-      return this;
-    };
-    const { strict, ...optionsWithoutStrict } = options;
-    Object.assign(this, optionsWithoutStrict);
-    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
-  }
-  #clone() {
-    const clone2 = new _Hono({
-      router: this.router,
-      getPath: this.getPath
-    });
-    clone2.errorHandler = this.errorHandler;
-    clone2.#notFoundHandler = this.#notFoundHandler;
-    clone2.routes = this.routes;
-    return clone2;
-  }
-  #notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler;
-  route(path, app) {
-    const subApp = this.basePath(path);
-    app.routes.map((r) => {
-      let handler;
-      if (app.errorHandler === errorHandler) {
-        handler = r.handler;
-      } else {
-        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
-        handler[COMPOSED_HANDLER] = r.handler;
-      }
-      subApp.#addRoute(r.method, r.path, handler);
-    });
-    return this;
-  }
-  basePath(path) {
-    const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path);
-    return subApp;
-  }
-  onError = (handler) => {
-    this.errorHandler = handler;
-    return this;
-  };
-  notFound = (handler) => {
-    this.#notFoundHandler = handler;
-    return this;
-  };
-  mount(path, applicationHandler, options) {
-    let replaceRequest;
-    let optionHandler;
-    if (options) {
-      if (typeof options === "function") {
-        optionHandler = options;
-      } else {
-        optionHandler = options.optionHandler;
-        if (options.replaceRequest === false) {
-          replaceRequest = (request) => request;
-        } else {
-          replaceRequest = options.replaceRequest;
-        }
-      }
-    }
-    const getOptions = optionHandler ? (c) => {
-      const options2 = optionHandler(c);
-      return Array.isArray(options2) ? options2 : [options2];
-    } : (c) => {
-      let executionContext = undefined;
-      try {
-        executionContext = c.executionCtx;
-      } catch {}
-      return [c.env, executionContext];
-    };
-    replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path);
-      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-      return (request) => {
-        const url = new URL(request.url);
-        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
-        return new Request(url, request);
-      };
-    })();
-    const handler = async (c, next) => {
-      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-      if (res) {
-        return res;
-      }
-      await next();
-    };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
-    return this;
-  }
-  #addRoute(method, path, handler) {
-    method = method.toUpperCase();
-    path = mergePath(this._basePath, path);
-    const r = { basePath: this._basePath, path, method, handler };
-    this.router.add(method, path, [handler, r]);
-    this.routes.push(r);
-  }
-  #handleError(err, c) {
-    if (err instanceof Error) {
-      return this.errorHandler(err, c);
-    }
-    throw err;
-  }
-  #dispatch(request, executionCtx, env, method) {
-    if (method === "HEAD") {
-      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
-    }
-    const path = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path);
-    const c = new Context(request, {
-      path,
-      matchResult,
-      env,
-      executionCtx,
-      notFoundHandler: this.#notFoundHandler
-    });
-    if (matchResult[0].length === 1) {
-      let res;
-      try {
-        res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.#notFoundHandler(c);
-        });
-      } catch (err) {
-        return this.#handleError(err, c);
-      }
-      return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
-    }
-    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
-    return (async () => {
-      try {
-        const context = await composed(c);
-        if (!context.finalized) {
-          throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
-        }
-        return context.res;
-      } catch (err) {
-        return this.#handleError(err, c);
-      }
-    })();
-  }
-  fetch = (request, ...rest) => {
-    return this.#dispatch(request, rest[1], rest[0], request.method);
-  };
-  request = (input, requestInit, Env, executionCtx) => {
-    if (input instanceof Request) {
-      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
-    }
-    input = input.toString();
-    return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
-  };
-  fire = () => {
-    addEventListener("fetch", (event) => {
-      event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method));
-    });
-  };
-};
-
-// node_modules/hono/dist/router/reg-exp-router/matcher.js
-var emptyParam = [];
-function match(method, path) {
-  const matchers = this.buildAllMatchers();
-  const match2 = (method2, path2) => {
-    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-    const staticMatch = matcher[2][path2];
-    if (staticMatch) {
-      return staticMatch;
-    }
-    const match3 = path2.match(matcher[0]);
-    if (!match3) {
-      return [[], emptyParam];
-    }
-    const index = match3.indexOf("", 1);
-    return [matcher[1][index], match3];
-  };
-  this.match = match2;
-  return match2(method, path);
-}
-
-// node_modules/hono/dist/router/reg-exp-router/node.js
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = /* @__PURE__ */ Symbol();
-var regExpMetaChars = new Set(".\\+*[^]$()");
-function compareKey(a, b) {
-  if (a.length === 1) {
-    return b.length === 1 ? a < b ? -1 : 1 : -1;
-  }
-  if (b.length === 1) {
-    return 1;
-  }
-  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
-  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
-    return -1;
-  }
-  if (a === LABEL_REG_EXP_STR) {
-    return 1;
-  } else if (b === LABEL_REG_EXP_STR) {
-    return -1;
-  }
-  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
-}
-var Node = class _Node {
-  #index;
-  #varIndex;
-  #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.#index !== undefined) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
-      }
-      this.#index = index;
-      return;
-    }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        if (regexpStr === ".*") {
-          throw PATH_ERROR;
-        }
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.#children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.#children).some((k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[regexpStr] = new _Node;
-        if (name !== "") {
-          node.#varIndex = context.varIndex++;
-        }
-      }
-      if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.#varIndex]);
-      }
-    } else {
-      node = this.#children[token];
-      if (!node) {
-        if (Object.keys(this.#children).some((k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[token] = new _Node;
-      }
-    }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
-  }
-  buildRegExpStr() {
-    const childKeys = Object.keys(this.#children).sort(compareKey);
-    const strList = childKeys.map((k) => {
-      const c = this.#children[k];
-      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-    });
-    if (typeof this.#index === "number") {
-      strList.unshift(`#${this.#index}`);
-    }
-    if (strList.length === 0) {
-      return "";
-    }
-    if (strList.length === 1) {
-      return strList[0];
-    }
-    return "(?:" + strList.join("|") + ")";
-  }
-};
-
-// node_modules/hono/dist/router/reg-exp-router/trie.js
-var Trie = class {
-  #context = { varIndex: 0 };
-  #root = new Node;
-  insert(path, index, pathErrorCheckOnly) {
-    const paramAssoc = [];
-    const groups = [];
-    for (let i = 0;; ) {
-      let replaced = false;
-      path = path.replace(/\{[^}]+\}/g, (m) => {
-        const mark = `@\\${i}`;
-        groups[i] = [mark, m];
-        i++;
-        replaced = true;
-        return mark;
-      });
-      if (!replaced) {
-        break;
-      }
-    }
-    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-    for (let i = groups.length - 1;i >= 0; i--) {
-      const [mark] = groups[i];
-      for (let j = tokens.length - 1;j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1]);
-          break;
-        }
-      }
-    }
-    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-    return paramAssoc;
-  }
-  buildRegExp() {
-    let regexp = this.#root.buildRegExpStr();
-    if (regexp === "") {
-      return [/^$/, [], []];
-    }
-    let captureIndex = 0;
-    const indexReplacementMap = [];
-    const paramReplacementMap = [];
-    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (handlerIndex !== undefined) {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex);
-        return "$()";
-      }
-      if (paramIndex !== undefined) {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-        return "";
-      }
-      return "";
-    });
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-  }
-};
-
-// node_modules/hono/dist/router/reg-exp-router/router.js
-var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
-var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path) {
-  return wildcardRegExpCache[path] ??= new RegExp(path === "*" ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
-}
-function clearWildcardRegExpCache() {
-  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-}
-function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie;
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map((route) => [!/\*|\/:/.test(route[0]), ...route]).sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length;i < len; i++) {
-    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
-    }
-    if (pathErrorCheckOnly) {
-      continue;
-    }
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (;paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount];
-        paramIndexMap[key] = value;
-      }
-      return [h, paramIndexMap];
-    });
-  }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length;i < len; i++) {
-    for (let j = 0, len2 = handlerData[i].length;j < len2; j++) {
-      const map2 = handlerData[i][j]?.[1];
-      if (!map2) {
-        continue;
-      }
-      const keys = Object.keys(map2);
-      for (let k = 0, len3 = keys.length;k < len3; k++) {
-        map2[keys[k]] = paramReplacementMap[map2[keys[k]]];
-      }
-    }
-  }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
-  }
-  return [regexp, handlerMap, staticMap];
-}
-function findMiddleware(middleware, path) {
-  if (!middleware) {
-    return;
-  }
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path)) {
-      return [...middleware[k]];
-    }
-  }
-  return;
-}
-var RegExpRouter = class {
-  name = "RegExpRouter";
-  #middleware;
-  #routes;
-  constructor() {
-    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-  }
-  add(method, path, handler) {
-    const middleware = this.#middleware;
-    const routes = this.#routes;
-    if (!middleware || !routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    if (!middleware[method]) {
-      [middleware, routes].forEach((handlerMap) => {
-        handlerMap[method] = /* @__PURE__ */ Object.create(null);
-        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
-          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
-        });
-      });
-    }
-    if (path === "/*") {
-      path = "*";
-    }
-    const paramCount = (path.match(/\/:/g) || []).length;
-    if (/\*$/.test(path)) {
-      const re = buildWildcardRegExp(path);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-        });
-      } else {
-        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-      }
-      Object.keys(middleware).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount]);
-          });
-        }
-      });
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(routes[m]).forEach((p) => re.test(p) && routes[m][p].push([handler, paramCount]));
-        }
-      });
-      return;
-    }
-    const paths = checkOptionalParameter(path) || [path];
-    for (let i = 0, len = paths.length;i < len; i++) {
-      const path2 = paths[i];
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path2] ||= [
-            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
-          ];
-          routes[m][path2].push([handler, paramCount - len + i + 1]);
-        }
-      });
-    }
-  }
-  match = match;
-  buildAllMatchers() {
-    const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
-      matchers[method] ||= this.#buildMatcher(method);
-    });
-    this.#middleware = this.#routes = undefined;
-    clearWildcardRegExpCache();
-    return matchers;
-  }
-  #buildMatcher(method) {
-    const routes = [];
-    let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true;
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]));
-      }
-    });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
-    }
-  }
-};
-
-// node_modules/hono/dist/router/reg-exp-router/prepared-router.js
-var PreparedRegExpRouter = class {
-  name = "PreparedRegExpRouter";
-  #matchers;
-  #relocateMap;
-  constructor(matchers, relocateMap) {
-    this.#matchers = matchers;
-    this.#relocateMap = relocateMap;
-  }
-  #addWildcard(method, handlerData) {
-    const matcher = this.#matchers[method];
-    matcher[1].forEach((list) => list && list.push(handlerData));
-    Object.values(matcher[2]).forEach((list) => list[0].push(handlerData));
-  }
-  #addPath(method, path, handler, indexes, map2) {
-    const matcher = this.#matchers[method];
-    if (!map2) {
-      matcher[2][path][0].push([handler, {}]);
-    } else {
-      indexes.forEach((index) => {
-        if (typeof index === "number") {
-          matcher[1][index].push([handler, map2]);
-        } else {
-          matcher[2][index || path][0].push([handler, map2]);
-        }
-      });
-    }
-  }
-  add(method, path, handler) {
-    if (!this.#matchers[method]) {
-      const all = this.#matchers[METHOD_NAME_ALL];
-      const staticMap = {};
-      for (const key in all[2]) {
-        staticMap[key] = [all[2][key][0].slice(), emptyParam];
-      }
-      this.#matchers[method] = [
-        all[0],
-        all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
-        staticMap
-      ];
-    }
-    if (path === "/*" || path === "*") {
-      const handlerData = [handler, {}];
-      if (method === METHOD_NAME_ALL) {
-        for (const m in this.#matchers) {
-          this.#addWildcard(m, handlerData);
-        }
-      } else {
-        this.#addWildcard(method, handlerData);
-      }
-      return;
-    }
-    const data = this.#relocateMap[path];
-    if (!data) {
-      throw new Error(`Path ${path} is not registered`);
-    }
-    for (const [indexes, map2] of data) {
-      if (method === METHOD_NAME_ALL) {
-        for (const m in this.#matchers) {
-          this.#addPath(m, path, handler, indexes, map2);
-        }
-      } else {
-        this.#addPath(method, path, handler, indexes, map2);
-      }
-    }
-  }
-  buildAllMatchers() {
-    return this.#matchers;
-  }
-  match = match;
-};
-
-// node_modules/hono/dist/router/smart-router/router.js
-var SmartRouter = class {
-  name = "SmartRouter";
-  #routers = [];
-  #routes = [];
-  constructor(init) {
-    this.#routers = init.routers;
-  }
-  add(method, path, handler) {
-    if (!this.#routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    this.#routes.push([method, path, handler]);
-  }
-  match(method, path) {
-    if (!this.#routes) {
-      throw new Error("Fatal error");
-    }
-    const routers = this.#routers;
-    const routes = this.#routes;
-    const len = routers.length;
-    let i = 0;
-    let res;
-    for (;i < len; i++) {
-      const router = routers[i];
-      try {
-        for (let i2 = 0, len2 = routes.length;i2 < len2; i2++) {
-          router.add(...routes[i2]);
-        }
-        res = router.match(method, path);
-      } catch (e) {
-        if (e instanceof UnsupportedPathError) {
-          continue;
-        }
-        throw e;
-      }
-      this.match = router.match.bind(router);
-      this.#routers = [router];
-      this.#routes = undefined;
-      break;
-    }
-    if (i === len) {
-      throw new Error("Fatal error");
-    }
-    this.name = `SmartRouter + ${this.activeRouter.name}`;
-    return res;
-  }
-  get activeRouter() {
-    if (this.#routes || this.#routers.length !== 1) {
-      throw new Error("No active router has been determined yet.");
-    }
-    return this.#routers[0];
-  }
-};
-
-// node_modules/hono/dist/router/trie-router/node.js
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var hasChildren = (children) => {
-  for (const _ in children) {
-    return true;
-  }
-  return false;
-};
-var Node2 = class _Node2 {
-  #methods;
-  #children;
-  #patterns;
-  #order = 0;
-  #params = emptyParams;
-  constructor(method, handler, children) {
-    this.#children = children || /* @__PURE__ */ Object.create(null);
-    this.#methods = [];
-    if (method && handler) {
-      const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0 };
-      this.#methods = [m];
-    }
-    this.#patterns = [];
-  }
-  insert(method, path, handler) {
-    this.#order = ++this.#order;
-    let curNode = this;
-    const parts = splitRoutingPath(path);
-    const possibleKeys = [];
-    for (let i = 0, len = parts.length;i < len; i++) {
-      const p = parts[i];
-      const nextP = parts[i + 1];
-      const pattern = getPattern(p, nextP);
-      const key = Array.isArray(pattern) ? pattern[0] : p;
-      if (key in curNode.#children) {
-        curNode = curNode.#children[key];
-        if (pattern) {
-          possibleKeys.push(pattern[1]);
-        }
-        continue;
-      }
-      curNode.#children[key] = new _Node2;
-      if (pattern) {
-        curNode.#patterns.push(pattern);
-        possibleKeys.push(pattern[1]);
-      }
-      curNode = curNode.#children[key];
-    }
-    curNode.#methods.push({
-      [method]: {
-        handler,
-        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-        score: this.#order
-      }
-    });
-    return curNode;
-  }
-  #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
-    for (let i = 0, len = node.#methods.length;i < len; i++) {
-      const m = node.#methods[i];
-      const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = {};
-      if (handlerSet !== undefined) {
-        handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSets.push(handlerSet);
-        if (nodeParams !== emptyParams || params && params !== emptyParams) {
-          for (let i2 = 0, len2 = handlerSet.possibleKeys.length;i2 < len2; i2++) {
-            const key = handlerSet.possibleKeys[i2];
-            const processed = processedSet[handlerSet.score];
-            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
-            processedSet[handlerSet.score] = true;
-          }
-        }
-      }
-    }
-  }
-  search(method, path) {
-    const handlerSets = [];
-    this.#params = emptyParams;
-    const curNode = this;
-    let curNodes = [curNode];
-    const parts = splitPath(path);
-    const curNodesQueue = [];
-    const len = parts.length;
-    let partOffsets = null;
-    for (let i = 0;i < len; i++) {
-      const part = parts[i];
-      const isLast = i === len - 1;
-      const tempNodes = [];
-      for (let j = 0, len2 = curNodes.length;j < len2; j++) {
-        const node = curNodes[j];
-        const nextNode = node.#children[part];
-        if (nextNode) {
-          nextNode.#params = node.#params;
-          if (isLast) {
-            if (nextNode.#children["*"]) {
-              this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
-            }
-            this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
-          } else {
-            tempNodes.push(nextNode);
-          }
-        }
-        for (let k = 0, len3 = node.#patterns.length;k < len3; k++) {
-          const pattern = node.#patterns[k];
-          const params = node.#params === emptyParams ? {} : { ...node.#params };
-          if (pattern === "*") {
-            const astNode = node.#children["*"];
-            if (astNode) {
-              this.#pushHandlerSets(handlerSets, astNode, method, node.#params);
-              astNode.#params = params;
-              tempNodes.push(astNode);
-            }
-            continue;
-          }
-          const [key, name, matcher] = pattern;
-          if (!part && !(matcher instanceof RegExp)) {
-            continue;
-          }
-          const child = node.#children[key];
-          if (matcher instanceof RegExp) {
-            if (partOffsets === null) {
-              partOffsets = new Array(len);
-              let offset = path[0] === "/" ? 1 : 0;
-              for (let p = 0;p < len; p++) {
-                partOffsets[p] = offset;
-                offset += parts[p].length + 1;
-              }
-            }
-            const restPathString = path.substring(partOffsets[i]);
-            const m = matcher.exec(restPathString);
-            if (m) {
-              params[name] = m[0];
-              this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
-              if (hasChildren(child.#children)) {
-                child.#params = params;
-                const componentCount = m[0].match(/\//)?.length ?? 0;
-                const targetCurNodes = curNodesQueue[componentCount] ||= [];
-                targetCurNodes.push(child);
-              }
-              continue;
-            }
-          }
-          if (matcher === true || matcher.test(part)) {
-            params[name] = part;
-            if (isLast) {
-              this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
-              if (child.#children["*"]) {
-                this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
-              }
-            } else {
-              child.#params = params;
-              tempNodes.push(child);
-            }
-          }
-        }
-      }
-      const shifted = curNodesQueue.shift();
-      curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
-    }
-    if (handlerSets.length > 1) {
-      handlerSets.sort((a, b) => {
-        return a.score - b.score;
-      });
-    }
-    return [handlerSets.map(({ handler, params }) => [handler, params])];
-  }
-};
-
-// node_modules/hono/dist/router/trie-router/router.js
-var TrieRouter = class {
-  name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new Node2;
-  }
-  add(method, path, handler) {
-    const results = checkOptionalParameter(path);
-    if (results) {
-      for (let i = 0, len = results.length;i < len; i++) {
-        this.#node.insert(method, results[i], handler);
-      }
-      return;
-    }
-    this.#node.insert(method, path, handler);
-  }
-  match(method, path) {
-    return this.#node.search(method, path);
-  }
-};
-
-// node_modules/hono/dist/hono.js
-var Hono2 = class extends Hono {
-  constructor(options = {}) {
-    super(options);
-    this.router = options.router ?? new SmartRouter({
-      routers: [new RegExpRouter, new TrieRouter]
-    });
-  }
-};
-
-// src/ui/styles.css
-var styles_default = `*,
-*::before,
-*::after {
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-}
-
-:root {
-  --bg: #fafafa;
-  --surface: #fff;
-  --border: #e0e0e0;
-  --text: #1a1a1a;
-  --text-muted: #666;
-  --primary: #2563eb;
-  --danger: #dc2626;
-  --sidebar-w: 220px;
-  --radius: 6px;
-  --gap: 16px;
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    --bg: #111;
-    --surface: #1a1a1a;
-    --border: #333;
-    --text: #e5e5e5;
-    --text-muted: #999;
-    --primary: #60a5fa;
-    --danger: #f87171;
-  }
-}
-
-body {
-  font-family: system-ui, -apple-system, sans-serif;
-  background: var(--bg);
-  color: var(--text);
-  line-height: 1.5;
-}
-
-.layout {
-  display: flex;
-  min-height: 100vh;
-}
-
-.sidebar {
-  width: var(--sidebar-w);
-  flex-shrink: 0;
-  border-right: 1px solid var(--border);
-  background: var(--surface);
-  padding: var(--gap) 0;
-  overflow-y: auto;
-}
-
-@media (min-width: 1200px) {
-  :root {
-    --sidebar-w: 280px;
-  }
-}
-
-@media (min-width: 1600px) {
-  :root {
-    --sidebar-w: 340px;
-  }
-}
-
-.sidebar h2 {
-  font-size: 0.75rem;
-  text-transform: uppercase;
-  color: var(--text-muted);
-  padding: 0 var(--gap);
-  margin-bottom: 8px;
-  letter-spacing: 0.05em;
-}
-
-.sidebar-item {
-  display: block;
-  width: 100%;
-  padding: 6px var(--gap);
-  font-size: 0.8125rem;
-  color: var(--text);
-  text-decoration: none;
-}
-
-.sidebar-item.ws-item {
-  direction: rtl;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  text-align: left;
-}
-
-.sidebar-item.ws-item span {
-  unicode-bidi: plaintext;
-}
-.sidebar-item:hover {
-  background: var(--bg);
-}
-.sidebar-item.active {
-  background: var(--primary);
-  color: #fff;
-}
-.sidebar-item.all-item {
-  font-weight: 500;
-}
-.sidebar-item.no-ws-item {
-  font-style: italic;
-  color: var(--text-muted);
-}
-.sidebar-item.no-ws-item.active {
-  color: #fff;
-}
-
-.main {
-  flex: 1;
-  min-width: 0;
-  padding: var(--gap);
-}
-
-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: var(--gap);
-}
-
-h1 {
-  font-size: 1.25rem;
-  font-weight: 600;
-}
-
-a.btn,
-button {
-  cursor: pointer;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  padding: 6px 12px;
-  background: var(--surface);
-  color: var(--text);
-  font-size: 0.875rem;
-  text-decoration: none;
-  display: inline-block;
-}
-
-a.btn:hover,
-button:hover {
-  border-color: var(--primary);
-}
-.primary {
-  background: var(--primary);
-  color: #fff;
-  border-color: var(--primary);
-}
-.danger {
-  color: var(--danger);
-}
-.danger:hover {
-  background: var(--danger);
-  color: #fff;
-  border-color: var(--danger);
-}
-
-.card {
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  padding: var(--gap);
-  margin-bottom: 12px;
-  background: var(--surface);
-}
-
-.card-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: flex-start;
-  margin-bottom: 8px;
-}
-
-.card-meta {
-  font-size: 0.75rem;
-  color: var(--text-muted);
-}
-
-.badge {
-  display: inline-block;
-  background: var(--bg);
-  border: 1px solid var(--border);
-  border-radius: 3px;
-  padding: 1px 6px;
-  font-size: 0.75rem;
-  color: var(--text-muted);
-}
-
-.card-content {
-  white-space: pre-wrap;
-  word-break: break-word;
-  font-size: 0.875rem;
-}
-.card-actions {
-  display: flex;
-  gap: 6px;
-  margin-top: 10px;
-}
-.card-actions form {
-  display: inline;
-}
-
-textarea {
-  width: 100%;
-  min-height: 80px;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  padding: 8px;
-  background: var(--surface);
-  color: var(--text);
-  font-family: inherit;
-  font-size: 0.875rem;
-  resize: vertical;
-}
-
-.form-card {
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  padding: var(--gap);
-  margin-bottom: var(--gap);
-  background: var(--surface);
-}
-
-.field {
-  margin-bottom: 10px;
-}
-.field label {
-  display: block;
-  font-size: 0.75rem;
-  color: var(--text-muted);
-  margin-bottom: 4px;
-}
-
-.field input {
-  width: 100%;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  padding: 6px 10px;
-  background: var(--surface);
-  color: var(--text);
-  font-size: 0.875rem;
-}
-
-.form-actions {
-  display: flex;
-  gap: 6px;
-}
-.load-more {
-  display: block;
-  width: 100%;
-  text-align: center;
-  padding: 10px;
-  margin-top: 8px;
-  text-decoration: none;
-}
-.empty {
-  text-align: center;
-  color: var(--text-muted);
-  padding: 40px 0;
-}
-
-.ws-group-header {
-  font-size: 0.75rem;
-  color: var(--text-muted);
-  margin: var(--gap) 0 8px;
-  padding-bottom: 4px;
-  border-bottom: 1px solid var(--border);
-}
-
-.pagination {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-top: var(--gap);
-  padding-top: var(--gap);
-  border-top: 1px solid var(--border);
-}
-
-.page-info {
-  font-size: 0.8125rem;
-  color: var(--text-muted);
-}
-
-@media (max-width: 640px) {
-  .layout {
-    flex-direction: column;
-  }
-
-  .sidebar {
-    width: 100%;
-    border-right: none;
-    border-bottom: 1px solid var(--border);
-    padding: 12px 0;
-    overflow-x: auto;
-    overflow-y: hidden;
-    white-space: nowrap;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 4px;
-  }
-
-  .sidebar h2 {
-    width: 100%;
-    margin-bottom: 4px;
-  }
-
-  .sidebar-item {
-    width: auto;
-    display: inline-block;
-    padding: 4px 10px;
-    border-radius: var(--radius);
-    border: 1px solid var(--border);
-    direction: ltr;
-  }
-}
-`;
-
-// src/ui/constants.ts
-var NO_WORKSPACE_FILTER = "__none__";
-
-// node_modules/hono/dist/jsx/constants.js
-var DOM_RENDERER = /* @__PURE__ */ Symbol("RENDERER");
-var DOM_ERROR_HANDLER = /* @__PURE__ */ Symbol("ERROR_HANDLER");
-var DOM_INTERNAL_TAG = /* @__PURE__ */ Symbol("INTERNAL");
-var PERMALINK = /* @__PURE__ */ Symbol("PERMALINK");
-
-// node_modules/hono/dist/jsx/dom/utils.js
-var setInternalTagFlag = (fn) => {
-  fn[DOM_INTERNAL_TAG] = true;
-  return fn;
-};
-
-// node_modules/hono/dist/jsx/dom/context.js
-var createContextProviderFunction = (values) => ({ value, children }) => {
-  if (!children) {
-    return;
-  }
-  const props = {
-    children: [
-      {
-        tag: setInternalTagFlag(() => {
-          values.push(value);
-        }),
-        props: {}
-      }
-    ]
-  };
-  if (Array.isArray(children)) {
-    props.children.push(...children.flat());
-  } else {
-    props.children.push(children);
-  }
-  props.children.push({
-    tag: setInternalTagFlag(() => {
-      values.pop();
-    }),
-    props: {}
-  });
-  const res = { tag: "", props, type: "" };
-  res[DOM_ERROR_HANDLER] = (err) => {
-    values.pop();
-    throw err;
-  };
-  return res;
-};
-
-// node_modules/hono/dist/jsx/context.js
-var globalContexts = [];
-var createContext = (defaultValue) => {
-  const values = [defaultValue];
-  const context = (props) => {
-    values.push(props.value);
-    let string4;
-    try {
-      string4 = props.children ? (Array.isArray(props.children) ? new JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
-    } catch (e) {
-      values.pop();
-      throw e;
-    }
-    if (string4 instanceof Promise) {
-      return string4.finally(() => values.pop()).then((resString) => raw(resString, resString.callbacks));
-    } else {
-      values.pop();
-      return raw(string4);
-    }
-  };
-  context.values = values;
-  context.Provider = context;
-  context[DOM_RENDERER] = createContextProviderFunction(values);
-  globalContexts.push(context);
-  return context;
-};
-var useContext = (context) => {
-  return context.values.at(-1);
-};
-
-// node_modules/hono/dist/jsx/intrinsic-element/common.js
-var deDupeKeyMap = {
-  title: [],
-  script: ["src"],
-  style: ["data-href"],
-  link: ["href"],
-  meta: ["name", "httpEquiv", "charset", "itemProp"]
-};
-var domRenderers = {};
-var dataPrecedenceAttr = "data-precedence";
-var isStylesheetLinkWithPrecedence = (props) => props.rel === "stylesheet" && ("precedence" in props);
-var shouldDeDupeByKey = (tagName, supportSort) => {
-  if (tagName === "link") {
-    return supportSort;
-  }
-  return deDupeKeyMap[tagName].length > 0;
-};
-
-// node_modules/hono/dist/jsx/intrinsic-element/components.js
-var exports_components = {};
-__export(exports_components, {
-  title: () => title,
-  style: () => style,
-  script: () => script,
-  meta: () => meta2,
-  link: () => link,
-  input: () => input,
-  form: () => form,
-  button: () => button
-});
-
-// node_modules/hono/dist/jsx/children.js
-var toArray = (children) => Array.isArray(children) ? children : [children];
-
-// node_modules/hono/dist/jsx/intrinsic-element/components.js
-var metaTagMap = /* @__PURE__ */ new WeakMap;
-var insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context }) => {
-  if (!buffer) {
-    return;
-  }
-  const map2 = metaTagMap.get(context) || {};
-  metaTagMap.set(context, map2);
-  const tags = map2[tagName] ||= [];
-  let duped = false;
-  const deDupeKeys = deDupeKeyMap[tagName];
-  const deDupeByKey = shouldDeDupeByKey(tagName, precedence !== undefined);
-  if (deDupeByKey) {
-    LOOP:
-      for (const [, tagProps] of tags) {
-        if (tagName === "link" && !(tagProps.rel === "stylesheet" && tagProps[dataPrecedenceAttr] !== undefined)) {
-          continue;
-        }
-        for (const key of deDupeKeys) {
-          if ((tagProps?.[key] ?? null) === props?.[key]) {
-            duped = true;
-            break LOOP;
-          }
-        }
-      }
-  }
-  if (duped) {
-    buffer[0] = buffer[0].replaceAll(tag, "");
-  } else if (deDupeByKey || tagName === "link") {
-    tags.push([tag, props, precedence]);
-  } else {
-    tags.unshift([tag, props, precedence]);
-  }
-  if (buffer[0].indexOf("</head>") !== -1) {
-    let insertTags;
-    if (tagName === "link" || precedence !== undefined) {
-      const precedences = [];
-      insertTags = tags.map(([tag2, , tagPrecedence], index) => {
-        if (tagPrecedence === undefined) {
-          return [tag2, Number.MAX_SAFE_INTEGER, index];
-        }
-        let order = precedences.indexOf(tagPrecedence);
-        if (order === -1) {
-          precedences.push(tagPrecedence);
-          order = precedences.length - 1;
-        }
-        return [tag2, order, index];
-      }).sort((a, b) => a[1] - b[1] || a[2] - b[2]).map(([tag2]) => tag2);
-    } else {
-      insertTags = tags.map(([tag2]) => tag2);
-    }
-    insertTags.forEach((tag2) => {
-      buffer[0] = buffer[0].replaceAll(tag2, "");
-    });
-    buffer[0] = buffer[0].replace(/(?=<\/head>)/, insertTags.join(""));
-  }
-};
-var returnWithoutSpecialBehavior = (tag, children, props) => raw(new JSXNode(tag, props, toArray(children ?? [])).toString());
-var documentMetadataTag = (tag, children, props, sort) => {
-  if ("itemProp" in props) {
-    return returnWithoutSpecialBehavior(tag, children, props);
-  }
-  let { precedence, blocking, ...restProps } = props;
-  precedence = sort ? precedence ?? "" : undefined;
-  if (sort) {
-    restProps[dataPrecedenceAttr] = precedence;
-  }
-  const string4 = new JSXNode(tag, restProps, toArray(children || [])).toString();
-  if (string4 instanceof Promise) {
-    return string4.then((resString) => raw(string4, [
-      ...resString.callbacks || [],
-      insertIntoHead(tag, resString, restProps, precedence)
-    ]));
-  } else {
-    return raw(string4, [insertIntoHead(tag, string4, restProps, precedence)]);
-  }
-};
-var title = ({ children, ...props }) => {
-  const nameSpaceContext = getNameSpaceContext();
-  if (nameSpaceContext) {
-    const context = useContext(nameSpaceContext);
-    if (context === "svg" || context === "head") {
-      return new JSXNode("title", props, toArray(children ?? []));
-    }
-  }
-  return documentMetadataTag("title", children, props, false);
-};
-var script = ({
-  children,
-  ...props
-}) => {
-  const nameSpaceContext = getNameSpaceContext();
-  if (["src", "async"].some((k) => !props[k]) || nameSpaceContext && useContext(nameSpaceContext) === "head") {
-    return returnWithoutSpecialBehavior("script", children, props);
-  }
-  return documentMetadataTag("script", children, props, false);
-};
-var style = ({
-  children,
-  ...props
-}) => {
-  if (!["href", "precedence"].every((k) => (k in props))) {
-    return returnWithoutSpecialBehavior("style", children, props);
-  }
-  props["data-href"] = props.href;
-  delete props.href;
-  return documentMetadataTag("style", children, props, true);
-};
-var link = ({ children, ...props }) => {
-  if (["onLoad", "onError"].some((k) => (k in props)) || props.rel === "stylesheet" && (!("precedence" in props) || ("disabled" in props))) {
-    return returnWithoutSpecialBehavior("link", children, props);
-  }
-  return documentMetadataTag("link", children, props, isStylesheetLinkWithPrecedence(props));
-};
-var meta2 = ({ children, ...props }) => {
-  const nameSpaceContext = getNameSpaceContext();
-  if (nameSpaceContext && useContext(nameSpaceContext) === "head") {
-    return returnWithoutSpecialBehavior("meta", children, props);
-  }
-  return documentMetadataTag("meta", children, props, false);
-};
-var newJSXNode = (tag, { children, ...props }) => new JSXNode(tag, props, toArray(children ?? []));
-var form = (props) => {
-  if (typeof props.action === "function") {
-    props.action = PERMALINK in props.action ? props.action[PERMALINK] : undefined;
-  }
-  return newJSXNode("form", props);
-};
-var formActionableElement = (tag, props) => {
-  if (typeof props.formAction === "function") {
-    props.formAction = PERMALINK in props.formAction ? props.formAction[PERMALINK] : undefined;
-  }
-  return newJSXNode(tag, props);
-};
-var input = (props) => formActionableElement("input", props);
-var button = (props) => formActionableElement("button", props);
-
-// node_modules/hono/dist/jsx/utils.js
-var normalizeElementKeyMap = /* @__PURE__ */ new Map([
-  ["className", "class"],
-  ["htmlFor", "for"],
-  ["crossOrigin", "crossorigin"],
-  ["httpEquiv", "http-equiv"],
-  ["itemProp", "itemprop"],
-  ["fetchPriority", "fetchpriority"],
-  ["noModule", "nomodule"],
-  ["formAction", "formaction"]
-]);
-var normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
-var styleObjectForEach = (style2, fn) => {
-  for (const [k, v] of Object.entries(style2)) {
-    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-    fn(key, v == null ? null : typeof v === "number" ? !key.match(/^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/) ? `${v}px` : `${v}` : v);
-  }
-};
-
-// node_modules/hono/dist/jsx/base.js
-var nameSpaceContext = undefined;
-var getNameSpaceContext = () => nameSpaceContext;
-var toSVGAttributeName = (key) => /[A-Z]/.test(key) && key.match(/^(?:al|basel|clip(?:Path|Rule)$|co|do|fill|fl|fo|gl|let|lig|i|marker[EMS]|o|pai|pointe|sh|st[or]|text[^L]|tr|u|ve|w)/) ? key.replace(/([A-Z])/g, "-$1").toLowerCase() : key;
-var emptyTags = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "keygen",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-];
-var booleanAttributes = [
-  "allowfullscreen",
-  "async",
-  "autofocus",
-  "autoplay",
-  "checked",
-  "controls",
-  "default",
-  "defer",
-  "disabled",
-  "download",
-  "formnovalidate",
-  "hidden",
-  "inert",
-  "ismap",
-  "itemscope",
-  "loop",
-  "multiple",
-  "muted",
-  "nomodule",
-  "novalidate",
-  "open",
-  "playsinline",
-  "readonly",
-  "required",
-  "reversed",
-  "selected"
-];
-var childrenToStringToBuffer = (children, buffer) => {
-  for (let i = 0, len = children.length;i < len; i++) {
-    const child = children[i];
-    if (typeof child === "string") {
-      escapeToBuffer(child, buffer);
-    } else if (typeof child === "boolean" || child === null || child === undefined) {
-      continue;
-    } else if (child instanceof JSXNode) {
-      child.toStringToBuffer(buffer);
-    } else if (typeof child === "number" || child.isEscaped) {
-      buffer[0] += child;
-    } else if (child instanceof Promise) {
-      buffer.unshift("", child);
-    } else {
-      childrenToStringToBuffer(child, buffer);
-    }
-  }
-};
-var JSXNode = class {
-  tag;
-  props;
-  key;
-  children;
-  isEscaped = true;
-  localContexts;
-  constructor(tag, props, children) {
-    this.tag = tag;
-    this.props = props;
-    this.children = children;
-  }
-  get type() {
-    return this.tag;
-  }
-  get ref() {
-    return this.props.ref || null;
-  }
-  toString() {
-    const buffer = [""];
-    this.localContexts?.forEach(([context, value]) => {
-      context.values.push(value);
-    });
-    try {
-      this.toStringToBuffer(buffer);
-    } finally {
-      this.localContexts?.forEach(([context]) => {
-        context.values.pop();
-      });
-    }
-    return buffer.length === 1 ? "callbacks" in buffer ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString() : buffer[0] : stringBufferToString(buffer, buffer.callbacks);
-  }
-  toStringToBuffer(buffer) {
-    const tag = this.tag;
-    const props = this.props;
-    let { children } = this;
-    buffer[0] += `<${tag}`;
-    const normalizeKey = nameSpaceContext && useContext(nameSpaceContext) === "svg" ? (key) => toSVGAttributeName(normalizeIntrinsicElementKey(key)) : (key) => normalizeIntrinsicElementKey(key);
-    for (let [key, v] of Object.entries(props)) {
-      key = normalizeKey(key);
-      if (key === "children") {} else if (key === "style" && typeof v === "object") {
-        let styleStr = "";
-        styleObjectForEach(v, (property, value) => {
-          if (value != null) {
-            styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
-          }
-        });
-        buffer[0] += ' style="';
-        escapeToBuffer(styleStr, buffer);
-        buffer[0] += '"';
-      } else if (typeof v === "string") {
-        buffer[0] += ` ${key}="`;
-        escapeToBuffer(v, buffer);
-        buffer[0] += '"';
-      } else if (v === null || v === undefined) {} else if (typeof v === "number" || v.isEscaped) {
-        buffer[0] += ` ${key}="${v}"`;
-      } else if (typeof v === "boolean" && booleanAttributes.includes(key)) {
-        if (v) {
-          buffer[0] += ` ${key}=""`;
-        }
-      } else if (key === "dangerouslySetInnerHTML") {
-        if (children.length > 0) {
-          throw new Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
-        }
-        children = [raw(v.__html)];
-      } else if (v instanceof Promise) {
-        buffer[0] += ` ${key}="`;
-        buffer.unshift('"', v);
-      } else if (typeof v === "function") {
-        if (!key.startsWith("on") && key !== "ref") {
-          throw new Error(`Invalid prop '${key}' of type 'function' supplied to '${tag}'.`);
-        }
-      } else {
-        buffer[0] += ` ${key}="`;
-        escapeToBuffer(v.toString(), buffer);
-        buffer[0] += '"';
-      }
-    }
-    if (emptyTags.includes(tag) && children.length === 0) {
-      buffer[0] += "/>";
-      return;
-    }
-    buffer[0] += ">";
-    childrenToStringToBuffer(children, buffer);
-    buffer[0] += `</${tag}>`;
-  }
-};
-var JSXFunctionNode = class extends JSXNode {
-  toStringToBuffer(buffer) {
-    const { children } = this;
-    const props = { ...this.props };
-    if (children.length) {
-      props.children = children.length === 1 ? children[0] : children;
-    }
-    const res = this.tag.call(null, props);
-    if (typeof res === "boolean" || res == null) {
-      return;
-    } else if (res instanceof Promise) {
-      if (globalContexts.length === 0) {
-        buffer.unshift("", res);
-      } else {
-        const currentContexts = globalContexts.map((c) => [c, c.values.at(-1)]);
-        buffer.unshift("", res.then((childRes) => {
-          if (childRes instanceof JSXNode) {
-            childRes.localContexts = currentContexts;
-          }
-          return childRes;
-        }));
-      }
-    } else if (res instanceof JSXNode) {
-      res.toStringToBuffer(buffer);
-    } else if (typeof res === "number" || res.isEscaped) {
-      buffer[0] += res;
-      if (res.callbacks) {
-        buffer.callbacks ||= [];
-        buffer.callbacks.push(...res.callbacks);
-      }
-    } else {
-      escapeToBuffer(res, buffer);
-    }
-  }
-};
-var JSXFragmentNode = class extends JSXNode {
-  toStringToBuffer(buffer) {
-    childrenToStringToBuffer(this.children, buffer);
-  }
-};
-var initDomRenderer = false;
-var jsxFn = (tag, props, children) => {
-  if (!initDomRenderer) {
-    for (const k in domRenderers) {
-      exports_components[k][DOM_RENDERER] = domRenderers[k];
-    }
-    initDomRenderer = true;
-  }
-  if (typeof tag === "function") {
-    return new JSXFunctionNode(tag, props, children);
-  } else if (exports_components[tag]) {
-    return new JSXFunctionNode(exports_components[tag], props, children);
-  } else if (tag === "svg" || tag === "head") {
-    nameSpaceContext ||= createContext("");
-    return new JSXNode(tag, props, [
-      new JSXFunctionNode(nameSpaceContext, {
-        value: tag
-      }, children)
-    ]);
-  } else {
-    return new JSXNode(tag, props, children);
-  }
-};
-var Fragment = ({
-  children
-}) => {
-  return new JSXFragmentNode("", {
-    children
-  }, Array.isArray(children) ? children : children ? [children] : []);
-};
-
-// node_modules/hono/dist/jsx/jsx-dev-runtime.js
-function jsxDEV(tag, props, key) {
-  let node;
-  if (!props || !("children" in props)) {
-    node = jsxFn(tag, props, []);
-  } else {
-    const children = props.children;
-    node = Array.isArray(children) ? jsxFn(tag, props, children) : jsxFn(tag, props, [children]);
-  }
-  node.key = key;
-  return node;
-}
-
-// src/ui/components/create-form.tsx
-function CreateForm({ workspace }) {
-  return /* @__PURE__ */ jsxDEV("div", {
-    class: "form-card",
-    children: /* @__PURE__ */ jsxDEV("form", {
-      method: "post",
-      action: "/memories",
-      children: [
-        /* @__PURE__ */ jsxDEV("div", {
-          class: "field",
-          children: [
-            /* @__PURE__ */ jsxDEV("label", {
-              for: "new-content",
-              children: "Content"
-            }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsxDEV("textarea", {
-              id: "new-content",
-              name: "content",
-              placeholder: "Fact, preference, decision...",
-              required: true
-            }, undefined, false, undefined, this)
-          ]
-        }, undefined, true, undefined, this),
-        /* @__PURE__ */ jsxDEV("div", {
-          class: "field",
-          children: [
-            /* @__PURE__ */ jsxDEV("label", {
-              for: "new-workspace",
-              children: "Workspace (optional)"
-            }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsxDEV("input", {
-              id: "new-workspace",
-              name: "workspace",
-              type: "text",
-              placeholder: "/path/to/project",
-              value: workspace && workspace !== NO_WORKSPACE_FILTER ? workspace : ""
-            }, undefined, false, undefined, this)
-          ]
-        }, undefined, true, undefined, this),
-        /* @__PURE__ */ jsxDEV("div", {
-          class: "form-actions",
-          children: /* @__PURE__ */ jsxDEV("button", {
-            type: "submit",
-            class: "primary",
-            children: "Save"
-          }, undefined, false, undefined, this)
-        }, undefined, false, undefined, this)
-      ]
-    }, undefined, true, undefined, this)
-  }, undefined, false, undefined, this);
-}
-
-// src/ui/components/memory-card.tsx
-function MemoryCard({ memory, editing, showWorkspace, returnUrl }) {
-  return /* @__PURE__ */ jsxDEV("div", {
-    class: "card",
-    children: [
-      /* @__PURE__ */ jsxDEV("div", {
-        class: "card-header",
-        children: /* @__PURE__ */ jsxDEV("div", {
-          class: "card-meta",
-          children: [
-            showWorkspace && memory.workspace && /* @__PURE__ */ jsxDEV(Fragment, {
-              children: [
-                /* @__PURE__ */ jsxDEV("span", {
-                  class: "badge",
-                  children: memory.workspace
-                }, undefined, false, undefined, this),
-                " "
-              ]
-            }, undefined, true, undefined, this),
-            memory.updatedAt.toLocaleString()
-          ]
-        }, undefined, true, undefined, this)
-      }, undefined, false, undefined, this),
-      editing ? /* @__PURE__ */ jsxDEV("form", {
-        method: "post",
-        action: `/memories/${encodeURIComponent(memory.id)}/update`,
-        children: [
-          /* @__PURE__ */ jsxDEV("input", {
-            type: "hidden",
-            name: "returnUrl",
-            value: returnUrl
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("textarea", {
-            name: "content",
-            required: true,
-            children: memory.content
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("div", {
-            class: "card-actions",
-            children: [
-              /* @__PURE__ */ jsxDEV("button", {
-                type: "submit",
-                class: "primary",
-                children: "Save"
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV("a", {
-                href: returnUrl,
-                class: "btn",
-                children: "Cancel"
-              }, undefined, false, undefined, this)
-            ]
-          }, undefined, true, undefined, this)
-        ]
-      }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV(Fragment, {
-        children: [
-          /* @__PURE__ */ jsxDEV("div", {
-            class: "card-content",
-            children: memory.content
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("div", {
-            class: "card-actions",
-            children: [
-              /* @__PURE__ */ jsxDEV("a", {
-                href: `${returnUrl}${returnUrl.includes("?") ? "&" : "?"}edit=${encodeURIComponent(memory.id)}`,
-                class: "btn",
-                children: "Edit"
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV("form", {
-                method: "post",
-                action: `/memories/${encodeURIComponent(memory.id)}/delete`,
-                onsubmit: "return confirm('Delete this memory?')",
-                children: [
-                  /* @__PURE__ */ jsxDEV("input", {
-                    type: "hidden",
-                    name: "returnUrl",
-                    value: returnUrl
-                  }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV("button", {
-                    type: "submit",
-                    class: "danger",
-                    children: "Delete"
-                  }, undefined, false, undefined, this)
-                ]
-              }, undefined, true, undefined, this)
-            ]
-          }, undefined, true, undefined, this)
-        ]
-      }, undefined, true, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-
-// src/ui/components/sidebar.tsx
-function Sidebar({ workspaces, selected }) {
-  return /* @__PURE__ */ jsxDEV("nav", {
-    class: "sidebar",
-    children: [
-      /* @__PURE__ */ jsxDEV("h2", {
-        children: "Workspaces"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("a", {
-        href: "/",
-        class: `sidebar-item all-item${selected === null ? " active" : ""}`,
-        children: "All"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("a", {
-        href: `/?workspace=${NO_WORKSPACE_FILTER}`,
-        class: `sidebar-item no-ws-item${selected === NO_WORKSPACE_FILTER ? " active" : ""}`,
-        children: "No workspace"
-      }, undefined, false, undefined, this),
-      workspaces.map((ws) => /* @__PURE__ */ jsxDEV("a", {
-        href: `/?workspace=${encodeURIComponent(ws)}`,
-        class: `sidebar-item ws-item${selected === ws ? " active" : ""}`,
-        title: ws,
-        children: /* @__PURE__ */ jsxDEV("span", {
-          children: ws.replace(/\/$/, "")
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this))
-    ]
-  }, undefined, true, undefined, this);
-}
-
-// src/ui/components/page.tsx
-function buildUrl(base, overrides) {
-  const url = new URL(base, "http://localhost");
-  for (const [key, value] of Object.entries(overrides)) {
-    url.searchParams.set(key, value);
-  }
-  return `${url.pathname}${url.search}`;
-}
-function Page({
-  memories,
-  workspaces,
-  selectedWorkspace,
-  editingId,
-  currentPage,
-  hasMore,
-  showCreate
-}) {
-  const params = new URLSearchParams;
-  if (selectedWorkspace)
-    params.set("workspace", selectedWorkspace);
-  if (currentPage > 1)
-    params.set("page", String(currentPage));
-  const baseUrl = params.size > 0 ? `/?${params.toString()}` : "/";
-  const showGroupHeaders = selectedWorkspace === null && new Set(memories.map((m) => m.workspace ?? null)).size > 1;
-  const grouped = [];
-  for (const m of memories) {
-    const key = m.workspace ?? "(no workspace)";
-    const last = grouped[grouped.length - 1];
-    if (last && last.key === key) {
-      last.items.push(m);
-    } else {
-      grouped.push({ key, items: [m] });
-    }
-  }
-  const hasPrev = currentPage > 1;
-  return /* @__PURE__ */ jsxDEV("html", {
-    lang: "en",
-    children: [
-      /* @__PURE__ */ jsxDEV("head", {
-        children: [
-          /* @__PURE__ */ jsxDEV("meta", {
-            charset: "utf-8"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("meta", {
-            name: "viewport",
-            content: "width=device-width, initial-scale=1"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("title", {
-            children: "agent-memory"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("style", {
-            children: styles_default
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV("body", {
-        children: /* @__PURE__ */ jsxDEV("div", {
-          class: "layout",
-          children: [
-            /* @__PURE__ */ jsxDEV(Sidebar, {
-              workspaces,
-              selected: selectedWorkspace
-            }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsxDEV("div", {
-              class: "main",
-              children: [
-                /* @__PURE__ */ jsxDEV("header", {
-                  children: [
-                    /* @__PURE__ */ jsxDEV("h1", {
-                      children: "agent-memory"
-                    }, undefined, false, undefined, this),
-                    showCreate ? /* @__PURE__ */ jsxDEV("a", {
-                      href: baseUrl,
-                      class: "btn",
-                      children: "Cancel"
-                    }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV("a", {
-                      href: buildUrl(baseUrl, { create: "1" }),
-                      class: "btn primary",
-                      children: "New Memory"
-                    }, undefined, false, undefined, this)
-                  ]
-                }, undefined, true, undefined, this),
-                showCreate && /* @__PURE__ */ jsxDEV(CreateForm, {
-                  workspace: selectedWorkspace
-                }, undefined, false, undefined, this),
-                memories.length === 0 && !hasPrev ? /* @__PURE__ */ jsxDEV("div", {
-                  class: "empty",
-                  children: "No memories found."
-                }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV(Fragment, {
-                  children: [
-                    grouped.map(({ key, items }) => /* @__PURE__ */ jsxDEV(Fragment, {
-                      children: [
-                        showGroupHeaders && /* @__PURE__ */ jsxDEV("div", {
-                          class: "ws-group-header",
-                          children: key
-                        }, undefined, false, undefined, this),
-                        items.map((m) => /* @__PURE__ */ jsxDEV(MemoryCard, {
-                          memory: m,
-                          editing: editingId === m.id,
-                          showWorkspace: selectedWorkspace === null,
-                          returnUrl: baseUrl
-                        }, undefined, false, undefined, this))
-                      ]
-                    }, undefined, true, undefined, this)),
-                    (hasPrev || hasMore) && /* @__PURE__ */ jsxDEV("div", {
-                      class: "pagination",
-                      children: [
-                        hasPrev ? /* @__PURE__ */ jsxDEV("a", {
-                          href: buildUrl(baseUrl, { page: String(currentPage - 1) }),
-                          class: "btn",
-                          children: "Previous"
-                        }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV("span", {}, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsxDEV("span", {
-                          class: "page-info",
-                          children: [
-                            "Page ",
-                            currentPage
-                          ]
-                        }, undefined, true, undefined, this),
-                        hasMore ? /* @__PURE__ */ jsxDEV("a", {
-                          href: buildUrl(baseUrl, { page: String(currentPage + 1) }),
-                          class: "btn",
-                          children: "Next"
-                        }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV("span", {}, undefined, false, undefined, this)
-                      ]
-                    }, undefined, true, undefined, this)
-                  ]
-                }, undefined, true, undefined, this)
-              ]
-            }, undefined, true, undefined, this)
-          ]
-        }, undefined, true, undefined, this)
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-
-// src/ui/routes/page-routes.tsx
-var DEFAULT_LIST_LIMIT3 = 15;
-function createPageRoutes(memory) {
-  const app = new Hono2;
-  async function renderPage(c) {
-    const workspace = c.req.query("workspace") ?? null;
-    const pageNum = Math.max(Number(c.req.query("page")) || 1, 1);
-    const editingId = c.req.query("edit") ?? null;
-    const showCreate = c.req.query("create") === "1";
-    const isNoWorkspace = workspace === NO_WORKSPACE_FILTER;
-    const wsFilter = workspace && !isNoWorkspace ? workspace : undefined;
-    const page = await memory.list({
-      workspace: wsFilter,
-      global: isNoWorkspace,
-      offset: (pageNum - 1) * DEFAULT_LIST_LIMIT3,
-      limit: DEFAULT_LIST_LIMIT3
-    });
-    const workspaces = await memory.listWorkspaces();
-    return c.html(/* @__PURE__ */ jsxDEV(Page, {
-      memories: page.items,
-      workspaces,
-      selectedWorkspace: workspace,
-      editingId,
-      currentPage: pageNum,
-      hasMore: page.hasMore,
-      showCreate
-    }, undefined, false, undefined, this));
-  }
-  async function createMemory(c) {
-    const form2 = await c.req.parseBody();
-    const content = typeof form2.content === "string" ? form2.content : "";
-    const workspace = typeof form2.workspace === "string" ? form2.workspace : undefined;
-    try {
-      await memory.create({ content, workspace });
-    } catch (error2) {
-      if (!(error2 instanceof ValidationError)) {
-        throw error2;
-      }
-    }
-    const wsParam = workspace?.trim() ? `/?workspace=${encodeURIComponent(workspace.trim())}` : "/";
-    return c.redirect(wsParam);
-  }
-  async function updateMemory(c) {
-    const form2 = await c.req.parseBody();
-    const content = typeof form2.content === "string" ? form2.content : "";
-    const returnUrl = safeReturnUrl(form2.returnUrl);
-    const id = c.req.param("id") ?? "";
-    try {
-      await memory.update({ id, content });
-    } catch (error2) {
-      if (!(error2 instanceof NotFoundError) && !(error2 instanceof ValidationError))
-        throw error2;
-    }
-    return c.redirect(returnUrl);
-  }
-  async function deleteMemory(c) {
-    const form2 = await c.req.parseBody();
-    const returnUrl = safeReturnUrl(form2.returnUrl);
-    const id = c.req.param("id") ?? "";
-    try {
-      await memory.delete({ id });
-    } catch (error2) {
-      if (!(error2 instanceof NotFoundError))
-        throw error2;
-    }
-    return c.redirect(returnUrl);
-  }
-  app.get("/", renderPage);
-  app.post("/memories", createMemory);
-  app.post("/memories/:id/update", updateMemory);
-  app.post("/memories/:id/delete", deleteMemory);
-  return app;
-}
-function safeReturnUrl(value) {
-  if (typeof value === "string" && value.startsWith("/"))
-    return value;
-  return "/";
-}
-
-// src/ui/server.tsx
-function startWebServer(memory, options) {
-  const app = new Hono2;
-  app.route("/", createPageRoutes(memory));
-  return serve({ fetch: app.fetch, port: options.port });
-}
-
-// src/workspace-resolver.ts
-import { execFile } from "node:child_process";
-import { basename, dirname as dirname2 } from "node:path";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-function createGitWorkspaceResolver(options = {}) {
-  const getGitCommonDir = options.getGitCommonDir ?? defaultGetGitCommonDir;
-  const cache = new Map;
-  return {
-    async resolve(workspace) {
-      const trimmed = normalizeOptionalString2(workspace);
-      if (!trimmed) {
-        return;
-      }
-      const cached2 = cache.get(trimmed);
-      if (cached2) {
-        return cached2;
-      }
-      const pending = resolveWorkspace(trimmed, getGitCommonDir);
-      cache.set(trimmed, pending);
-      return pending;
-    }
-  };
-}
-async function resolveWorkspace(workspace, getGitCommonDir) {
-  try {
-    const gitCommonDir = (await getGitCommonDir(workspace)).trim();
-    if (basename(gitCommonDir) !== ".git") {
-      return workspace;
-    }
-    return dirname2(gitCommonDir);
-  } catch {
-    return workspace;
-  }
-}
-async function defaultGetGitCommonDir(cwd) {
-  const { stdout } = await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
-    cwd
-  });
-  return stdout.trim();
-}
-function normalizeOptionalString2(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
+async function defaultGetGitCommonDir(cwd) {
+  const { stdout } = await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+    cwd
+  });
+  return stdout.trim();
 }
 
 // src/index.ts
 var config2 = resolveConfig();
 var workspaceResolver = createGitWorkspaceResolver();
-var database = await openMemoryDatabase(config2.databasePath, { workspaceResolver });
-var repository2 = new SqliteMemoryRepository(database);
+var repository2 = new FilesystemMemoryRepository(config2.storePath);
 var memoryService = new MemoryService(repository2, workspaceResolver);
-if (config2.uiMode) {
-  let shutdown = function() {
-    server.close();
-    database.close();
-    process.exit(0);
-  };
-  const server = startWebServer(memoryService, { port: config2.uiPort });
-  const addr = server.address();
-  const port = typeof addr === "object" && addr ? addr.port : config2.uiPort;
-  console.log(`agent-memory UI running at http://localhost:${port}`);
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-} else {
-  const server = createMcpServer(memoryService, version2);
-  const transport = new StdioServerTransport;
-  try {
-    await server.connect(transport);
-  } catch (error2) {
-    console.error(error2 instanceof Error ? error2.message : "Failed to start agent-memory.");
-    database.close();
-    process.exit(1);
-  }
+var server = createMcpServer(memoryService, version2);
+var transport = new StdioServerTransport;
+try {
+  await server.connect(transport);
+} catch (error2) {
+  console.error(error2 instanceof Error ? error2.message : "Failed to start agent-memory.");
+  process.exit(1);
 }