lopata 0.4.3 → 0.5.0

package/dist/dashboard/{chunk-paesqsyf.css → chunk-a68x1m5f.css}

@@ -2408,6 +2408,12 @@
     }
   }
 
+  @media (hover: hover) {
+    .hover\:bg-red-700:hover {
+      background-color: var(--color-red-700);
+    }
+  }
+
   @media (hover: hover) {
     .hover\:bg-yellow-500\/25:hover {
       background-color: #edb20040;

package/dist/dashboard/{chunk-ymq225fp.js → chunk-rae638a4.js}

@@ -4538,6 +4538,8 @@ function DoInstanceDetail({ ns, id, basePath, routeTab, routeTable, routeQuery }
   const { data, refetch } = useQuery("do.getInstance", { ns, id });
   const deleteEntry = useMutation("do.deleteEntry");
   const triggerAlarm = useMutation("do.triggerAlarm");
+  const cancelAlarm = useMutation("do.cancelAlarm");
+  const deleteInstance = useMutation("do.deleteInstance");
   const { data: sqlTables } = useQuery("do.listSqlTables", { ns, id });
   const handleDelete = async (key) => {
     if (!confirm(`Delete storage key "${key}"?`))
@@ -4549,6 +4551,16 @@ function DoInstanceDetail({ ns, id, basePath, routeTab, routeTable, routeQuery }
     await triggerAlarm.mutate({ ns, id });
     refetch();
   };
+  const handleCancelAlarm = async () => {
+    await cancelAlarm.mutate({ ns, id });
+    refetch();
+  };
+  const handleDeleteInstance = async () => {
+    if (!confirm(`Delete this Durable Object instance? All storage data will be permanently removed.`))
+      return;
+    await deleteInstance.mutate({ ns, id });
+    location.hash = `#/do/${encodeURIComponent(ns)}`;
+  };
   if (!data)
     return /* @__PURE__ */ u3("div", {
       class: "p-4 sm:p-8 text-text-muted font-medium",
@@ -4565,23 +4577,42 @@ function DoInstanceDetail({ ns, id, basePath, routeTab, routeTable, routeQuery }
         ]
       }, undefined, false, undefined, this),
       /* @__PURE__ */ u3("div", {
-        class: "mb-6 flex justify-end",
-        children: /* @__PURE__ */ u3(RefreshButton, {
-          onClick: refetch
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this),
+        class: "mb-6 flex justify-end gap-2",
+        children: [
+          /* @__PURE__ */ u3("button", {
+            onClick: handleDeleteInstance,
+            disabled: deleteInstance.isLoading,
+            class: "rounded-md px-3 py-1.5 text-xs font-medium bg-red-600 text-white hover:bg-red-700 disabled:opacity-40 disabled:cursor-not-allowed transition-all",
+            children: deleteInstance.isLoading ? "Deleting..." : "Delete instance"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ u3(RefreshButton, {
+            onClick: refetch
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
       (data.alarm || data.hasAlarmHandler) && /* @__PURE__ */ u3("div", {
         class: "mb-6 px-4 py-3 bg-panel-secondary border border-border rounded-lg text-sm font-medium text-ink flex items-center justify-between",
         children: [
           /* @__PURE__ */ u3("span", {
             children: data.alarm ? `Alarm set for: ${formatTime(data.alarm)}` : "No alarm scheduled"
           }, undefined, false, undefined, this),
-          data.hasAlarmHandler && /* @__PURE__ */ u3("button", {
-            onClick: handleTriggerAlarm,
-            disabled: triggerAlarm.isLoading,
-            class: "rounded-md px-3 py-1.5 text-xs font-medium bg-ink text-surface hover:opacity-80 disabled:opacity-40 disabled:cursor-not-allowed transition-all",
-            children: triggerAlarm.isLoading ? "Triggering..." : "Trigger now"
-          }, undefined, false, undefined, this)
+          /* @__PURE__ */ u3("div", {
+            class: "flex gap-2",
+            children: [
+              data.alarm && /* @__PURE__ */ u3("button", {
+                onClick: handleCancelAlarm,
+                disabled: cancelAlarm.isLoading,
+                class: "rounded-md px-3 py-1.5 text-xs font-medium bg-red-600 text-white hover:bg-red-700 disabled:opacity-40 disabled:cursor-not-allowed transition-all",
+                children: cancelAlarm.isLoading ? "Cancelling..." : "Cancel"
+              }, undefined, false, undefined, this),
+              data.hasAlarmHandler && /* @__PURE__ */ u3("button", {
+                onClick: handleTriggerAlarm,
+                disabled: triggerAlarm.isLoading,
+                class: "rounded-md px-3 py-1.5 text-xs font-medium bg-ink text-surface hover:opacity-80 disabled:opacity-40 disabled:cursor-not-allowed transition-all",
+                children: triggerAlarm.isLoading ? "Triggering..." : "Trigger now"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
       data.entries.length === 0 ? /* @__PURE__ */ u3(EmptyState, {

package/dist/dashboard/index.html

@@ -8,7 +8,7 @@
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
   
-<link rel="stylesheet" crossorigin href="/__dashboard/assets/chunk-paesqsyf.css"><script type="module" crossorigin src="/__dashboard/assets/chunk-ymq225fp.js"></script></head>
+<link rel="stylesheet" crossorigin href="/__dashboard/assets/chunk-a68x1m5f.css"><script type="module" crossorigin src="/__dashboard/assets/chunk-rae638a4.js"></script></head>
 <body class="h-full bg-surface text-ink" style="font-family: system-ui, -apple-system, sans-serif;">
   <script>
     // Apply saved theme before first paint to prevent flash

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lopata",
-	"version": "0.4.3",
+	"version": "0.5.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {

package/src/api/handlers/do.ts

@@ -94,6 +94,20 @@ export const handlers = {
 		return { ok: true }
 	},
 
+	'do.cancelAlarm'({ ns, id }: { ns: string; id: string }, ctx: HandlerContext): OkResponse {
+		const namespace = getDoNamespace(ctx, ns)
+		if (!namespace) throw new Error(`Durable Object namespace "${ns}" not found (worker not loaded?)`)
+		namespace.cancelAlarm(id)
+		return { ok: true }
+	},
+
+	'do.deleteInstance'({ ns, id }: { ns: string; id: string }, ctx: HandlerContext): OkResponse {
+		const namespace = getDoNamespace(ctx, ns)
+		if (!namespace) throw new Error(`Durable Object namespace "${ns}" not found (worker not loaded?)`)
+		namespace.deleteInstance(id)
+		return { ok: true }
+	},
+
 	async 'do.generateSql'({ ns, id, prompt }: { ns: string; id: string; prompt: string }, ctx: HandlerContext): Promise<{ sql: string }> {
 		const dbPath = join(getDataDir(), 'do-sql', ns, `${id}.sqlite`)
 		if (!existsSync(dbPath)) throw new Error('SQL database not found for this instance')

package/src/bindings/durable-object.ts

@@ -1,5 +1,5 @@
 import { Database, type SQLQueryBindings } from 'bun:sqlite'
-import { mkdirSync, statSync } from 'node:fs'
+import { existsSync, mkdirSync, rmSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { persistError, startSpan } from '../tracing/span'
 import type { ContainerContext } from './container'
@@ -952,6 +952,54 @@ export class DurableObjectNamespaceImpl {
 		return this._fireAlarm(idStr, 0)
 	}
 
+	/** @internal Cancel a scheduled alarm without firing it */
+	cancelAlarm(idStr: string): void {
+		const timer = this.alarmTimers.get(idStr)
+		if (timer) clearTimeout(timer)
+		this.alarmTimers.delete(idStr)
+		this.db
+			.query('DELETE FROM do_alarms WHERE namespace = ? AND id = ?')
+			.run(this.namespaceName, idStr)
+	}
+
+	/** @internal Delete a DO instance and all its data */
+	deleteInstance(idStr: string): void {
+		this.cancelAlarm(idStr)
+
+		const executor = this._executors.get(idStr)
+		if (executor) {
+			executor.dispose().catch(() => {})
+			this._executors.delete(idStr)
+		}
+		this._stubs.delete(idStr)
+		this._knownIds.delete(idStr)
+		this._lastActivity.delete(idStr)
+
+		this.db.run('BEGIN')
+		try {
+			this.db.query('DELETE FROM do_instances WHERE namespace = ? AND id = ?').run(this.namespaceName, idStr)
+			this.db.query('DELETE FROM do_storage WHERE namespace = ? AND id = ?').run(this.namespaceName, idStr)
+			this.db.query('DELETE FROM do_alarms WHERE namespace = ? AND id = ?').run(this.namespaceName, idStr)
+			this.db.run('COMMIT')
+		} catch (e) {
+			this.db.run('ROLLBACK')
+			throw e
+		}
+
+		// Delete SQL storage database files
+		if (this.dataDir) {
+			const sqlDbPath = join(this.dataDir, 'do-sql', this.namespaceName, `${idStr}.sqlite`)
+			if (existsSync(sqlDbPath)) {
+				rmSync(sqlDbPath, { force: true })
+				// Clean up WAL/SHM files
+				for (const suffix of ['-wal', '-shm']) {
+					const walPath = sqlDbPath + suffix
+					if (existsSync(walPath)) rmSync(walPath, { force: true })
+				}
+			}
+		}
+	}
+
 	newUniqueId(_options?: { jurisdiction?: string }): DurableObjectIdImpl {
 		return new DurableObjectIdImpl(crypto.randomUUID().replace(/-/g, ''))
 	}

package/src/vite-plugin/config-plugin.ts

@@ -19,7 +19,7 @@ class LopataDevEnvironment extends DevEnvironment {
 
 	get runner(): ModuleRunner {
 		if (!this._runner) {
-			this._runner = createServerModuleRunner(this)
+			this._runner = createServerModuleRunner(this, { hmr: false })
 		}
 		return this._runner
 	}

package/src/vite-plugin/dev-server-plugin.ts

@@ -52,8 +52,8 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	let currentModule: Record<string, unknown> | null = null
 	// Serializes module reload — prevents concurrent wireClassRefs calls
 	let reloadLock: Promise<void> | null = null
-	// Flag set on file change; next request will clear runner cache
-	let needsReload = false
+	// Files changed since last request — coalesced into a single invalidation batch
+	let changedFiles: Set<string> = new Set()
 
 	return {
 		name: 'lopata:dev-server',
@@ -168,18 +168,17 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 			}
 
 			// 5. Track SSR-relevant file changes.
-			// Vite's built-in HMR flow invalidates the module graph and sends
-			// full-reload events to the runner. However, the runner's async HMR
-			// handler can race with incoming requests. We set a flag here and
-			// clear the runner's evaluated module cache on the next request,
-			// ensuring a clean re-evaluation from the freshly-invalidated module graph.
+			// Collect changed file paths; the next request will invalidate only
+			// the affected modules (and their transitive importers) instead of
+			// clearing the entire runner cache.  HMR on the runner is disabled
+			// (hmr: false in config-plugin) so there's no async race.
 			server.watcher.on('change', (file) => {
 				const ssrEnv = server.environments[options.envName]
 				if (!ssrEnv) return
 				const normalizedFile = file.replace(/\\/g, '/')
 				const mods = ssrEnv.moduleGraph.getModulesByFile(normalizedFile)
 				if (mods && mods.size > 0) {
-					needsReload = true
+					changedFiles.add(normalizedFile)
 					currentModule = null
 				}
 			})
@@ -244,17 +243,18 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 						// Wait for any in-progress reload before importing
 						if (reloadLock) await reloadLock
 
-						// Clear runner's evaluated module cache when files changed.
-						// The module graph is already invalidated by Vite's onFileChange,
-						// but the runner caches evaluated modules independently.
-						// Using .clear() (like the Cloudflare plugin) wipes all three
-						// maps (idToModuleMap, fileToModulesMap, urlToIdModuleMap),
-						// forcing a full re-evaluation from the fresh module graph.
-						if (needsReload) {
-							needsReload = false
-							const runner = (ssrEnv as { runner: { evaluatedModules: { clear(): void } } }).runner
-							runner.evaluatedModules.clear()
-							console.log('[lopata:vite] Cleared runner module cache (file change detected)')
+						// Granular invalidation: only invalidate modules for changed
+						// files and their transitive importers, instead of wiping the
+						// entire runner cache.  This preserves cached evaluations of
+						// unchanged modules for faster re-evaluation.
+						if (changedFiles.size > 0) {
+							const files = changedFiles
+							changedFiles = new Set()
+							const runner = (ssrEnv as any).runner
+							const count = invalidateChangedModules(runner.evaluatedModules, files)
+							if (count > 0) {
+								console.log(`[lopata:vite] Invalidated ${count} module(s) (${files.size} file(s) changed)`)
+							}
 						}
 
 						const workerModule = await (ssrEnv as any).runner.import(entrypoint) as Record<string, unknown>
@@ -452,6 +452,52 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	}
 }
 
+/**
+ * Invalidate runner-evaluated modules for the given changed files and all
+ * their transitive importers.  Virtual modules (IDs starting with `\0`) are
+ * skipped to preserve shimmed CF modules (see commit 75b1736).
+ *
+ * Returns the number of modules invalidated.
+ */
+function invalidateChangedModules(
+	evaluatedModules: { getModulesByFile(file: string): Iterable<{ id: string; importers: Set<any> }> | undefined; invalidateModule(node: any): void },
+	changedFiles: Set<string>,
+): number {
+	const toInvalidate = new Set<{ id: string; importers: Set<any> }>()
+
+	for (const file of changedFiles) {
+		const nodes = evaluatedModules.getModulesByFile(file)
+		if (!nodes) continue
+		for (const node of nodes) {
+			collectTransitiveImporters(node, toInvalidate)
+		}
+	}
+
+	for (const node of toInvalidate) {
+		evaluatedModules.invalidateModule(node)
+	}
+
+	return toInvalidate.size
+}
+
+/**
+ * Collect `node` and all its transitive importers into `result`.
+ * Skips virtual modules (IDs starting with `\0`) — these are CF module shims
+ * that must not be invalidated or traversed further.
+ */
+function collectTransitiveImporters(
+	node: { id: string; importers: Set<any> },
+	result: Set<{ id: string; importers: Set<any> }>,
+): void {
+	if (result.has(node)) return
+	// Skip virtual modules — CF shims must stay cached
+	if (node.id.startsWith('\0')) return
+	result.add(node)
+	for (const importer of node.importers) {
+		collectTransitiveImporters(importer, result)
+	}
+}
+
 function stitchAsyncStack(err: Error, callerError: Error | null): void {
 	if (!callerError) return
 	if (!err.stack || !callerError.stack) return