libpetri 0.5.3 → 0.6.0

package/dist/debug/index.d.ts

@@ -1,6 +1,6 @@
+import { Writable } from 'node:stream';
 import { a as PetriNet, b as Transition, T as Token } from '../petri-net-C3Jy5HCt.js';
 import { E as EventStore, N as NetEvent } from '../event-store-Y8q_wapJ.js';
-import { Writable } from 'node:stream';
 
 /**
  * Commands sent from debug UI client to server via WebSocket.
@@ -66,6 +66,17 @@ type DebugCommand = {
 } | {
     readonly type: 'listBreakpoints';
     readonly sessionId: string;
+} | {
+    readonly type: 'listArchives';
+    readonly limit?: number;
+    readonly prefix?: string;
+} | {
+    readonly type: 'importArchive';
+    readonly sessionId: string;
+} | {
+    readonly type: 'uploadArchive';
+    readonly fileName: string;
+    readonly data: string;
 };
 declare function eventFilterAll(): EventFilter;
 
@@ -110,6 +121,12 @@ interface NetStructure {
     readonly places: readonly PlaceInfo[];
     readonly transitions: readonly TransitionInfo[];
 }
+interface ArchiveSummary {
+    readonly sessionId: string;
+    readonly key: string;
+    readonly sizeBytes: number;
+    readonly lastModified: string;
+}
 type DebugResponse = {
     readonly type: 'sessionList';
     readonly sessions: readonly SessionSummary[];
@@ -177,8 +194,35 @@ type DebugResponse = {
     readonly code: string;
     readonly message: string;
     readonly sessionId: string | null;
+} | {
+    readonly type: 'archiveList';
+    readonly archives: readonly ArchiveSummary[];
+    readonly storageAvailable: boolean;
+} | {
+    readonly type: 'archiveImported';
+    readonly sessionId: string;
+    readonly netName: string;
+    readonly eventCount: number;
 };
 
+/**
+ * Storage backend interface for session archives.
+ */
+
+interface ArchivedSessionSummary {
+    readonly sessionId: string;
+    readonly key: string;
+    readonly sizeBytes: number;
+    readonly lastModified: number;
+}
+type OutputStreamConsumer = (out: Writable) => Promise<void>;
+interface SessionArchiveStorage {
+    storeStreaming(sessionId: string, writer: OutputStreamConsumer): Promise<void>;
+    list(limit: number, prefix?: string): Promise<readonly ArchivedSessionSummary[]>;
+    retrieve(sessionId: string): Promise<Buffer>;
+    isAvailable(): boolean;
+}
+
 /**
  * Analyze places for start/end/environment classification.
  * TypeScript port of Java's PlaceAnalysis.
@@ -331,8 +375,9 @@ interface ComputedState {
 }
 declare class DebugProtocolHandler {
     private readonly _sessionRegistry;
+    private readonly _archiveStorage;
     private readonly _clients;
-    constructor(sessionRegistry: DebugSessionRegistry);
+    constructor(sessionRegistry: DebugSessionRegistry, archiveStorage?: SessionArchiveStorage | null);
     /** Registers a new client connection. */
     clientConnected(clientId: string, sink: ResponseSink): void;
     /** Cleans up when a client disconnects. */
@@ -354,6 +399,10 @@ declare class DebugProtocolHandler {
     private handleSetBreakpoint;
     private handleClearBreakpoint;
     private handleListBreakpoints;
+    private handleListArchives;
+    private handleImportArchive;
+    private handleUploadArchive;
+    private broadcastSessionList;
     private send;
     private sendError;
     private sendInBatches;
@@ -430,24 +479,6 @@ interface SessionArchive {
 /** Current archive format version. */
 declare const CURRENT_VERSION = 1;
 
-/**
- * Storage backend interface for session archives.
- */
-
-interface ArchivedSessionSummary {
-    readonly sessionId: string;
-    readonly key: string;
-    readonly sizeBytes: number;
-    readonly lastModified: number;
-}
-type OutputStreamConsumer = (out: Writable) => Promise<void>;
-interface SessionArchiveStorage {
-    storeStreaming(sessionId: string, writer: OutputStreamConsumer): Promise<void>;
-    list(limit: number, prefix?: string): Promise<readonly ArchivedSessionSummary[]>;
-    retrieve(sessionId: string): Promise<Buffer>;
-    isAvailable(): boolean;
-}
-
 /**
  * File-system backed storage for session archives.
  * Uses Node.js fs/promises — no external dependencies.
@@ -510,4 +541,4 @@ declare class SessionArchiveReader {
  */
 declare function debugUiAssetPath(): Promise<string>;
 
-export { type ArchivedSessionSummary, type BreakpointConfig, type BreakpointType, CURRENT_VERSION, type ComputedState, DEFAULT_MAX_EVENTS, DebugAwareEventStore, type DebugCommand, DebugEventStore, DebugProtocolHandler, type DebugResponse, type DebugSession, DebugSessionRegistry, type EventFilter, type EventStoreFactory, FileSessionArchiveStorage, type ImportedSession, MarkingCache, type NetEventInfo, type NetStructure, type OutputStreamConsumer, PlaceAnalysis, type PlaceAnalysisInfo, type PlaceInfo, type ResponseSink, SNAPSHOT_INTERVAL, type SessionArchive, SessionArchiveReader, type SessionArchiveStorage, SessionArchiveWriter, type SessionCompletionListener, type SessionSummary, type Subscription, type SubscriptionMode, type TokenInfo, type TransitionInfo, buildNetStructure, compactTokenInfo, convertMarking, debugUiAssetPath, eventFilterAll, toEventInfo, tokenInfo };
+export { type ArchiveSummary, type ArchivedSessionSummary, type BreakpointConfig, type BreakpointType, CURRENT_VERSION, type ComputedState, DEFAULT_MAX_EVENTS, DebugAwareEventStore, type DebugCommand, DebugEventStore, DebugProtocolHandler, type DebugResponse, type DebugSession, DebugSessionRegistry, type EventFilter, type EventStoreFactory, FileSessionArchiveStorage, type ImportedSession, MarkingCache, type NetEventInfo, type NetStructure, type OutputStreamConsumer, PlaceAnalysis, type PlaceAnalysisInfo, type PlaceInfo, type ResponseSink, SNAPSHOT_INTERVAL, type SessionArchive, SessionArchiveReader, type SessionArchiveStorage, SessionArchiveWriter, type SessionCompletionListener, type SessionSummary, type Subscription, type SubscriptionMode, type TokenInfo, type TransitionInfo, buildNetStructure, compactTokenInfo, convertMarking, debugUiAssetPath, eventFilterAll, toEventInfo, tokenInfo };

package/dist/debug/index.js

@@ -9,76 +9,8 @@ function eventFilterAll() {
   return { eventTypes: null, transitionNames: null, placeNames: null };
 }
 
-// src/debug/place-analysis.ts
-var PlaceAnalysis = class _PlaceAnalysis {
-  _data;
-  constructor(data) {
-    this._data = data;
-  }
-  get data() {
-    return this._data;
-  }
-  isStart(placeName) {
-    const info = this._data.get(placeName);
-    return info != null && !info.hasIncoming;
-  }
-  isEnd(placeName) {
-    const info = this._data.get(placeName);
-    return info != null && !info.hasOutgoing;
-  }
-  /** Build place analysis from a PetriNet. */
-  static from(net) {
-    const data = /* @__PURE__ */ new Map();
-    function ensure(place) {
-      let info = data.get(place.name);
-      if (!info) {
-        info = { tokenType: "unknown", hasIncoming: false, hasOutgoing: false };
-        data.set(place.name, info);
-      }
-      return info;
-    }
-    for (const transition of net.transitions) {
-      for (const input of transition.inputSpecs) {
-        const info = ensure(input.place);
-        info.hasOutgoing = true;
-      }
-      if (transition.outputSpec) {
-        const outputPlaces = collectOutputPlaces(transition.outputSpec);
-        for (const place of outputPlaces) {
-          const info = ensure(place);
-          info.hasIncoming = true;
-        }
-      }
-      for (const inh of transition.inhibitors) {
-        ensure(inh.place);
-      }
-      for (const read of transition.reads) {
-        const info = ensure(read.place);
-        info.hasOutgoing = true;
-      }
-      for (const reset of transition.resets) {
-        ensure(reset.place);
-      }
-    }
-    return new _PlaceAnalysis(data);
-  }
-};
-function collectOutputPlaces(out) {
-  const spec = out;
-  switch (spec.type) {
-    case "place":
-      return spec.place ? [spec.place] : [];
-    case "and":
-    case "xor":
-      return (spec.children ?? []).flatMap((c) => collectOutputPlaces(c));
-    case "timeout":
-      return spec.child ? collectOutputPlaces(spec.child) : [];
-    case "forward-input":
-      return spec.to ? [spec.to] : [];
-    default:
-      return [];
-  }
-}
+// src/debug/archive/session-archive-reader.ts
+import { gunzipSync } from "zlib";
 
 // src/debug/debug-event-store.ts
 var DEFAULT_MAX_EVENTS = 1e4;
@@ -185,6 +117,188 @@ var DebugEventStore = class {
   }
 };
 
+// src/debug/archive/session-archive.ts
+var CURRENT_VERSION = 1;
+
+// src/debug/archive/session-archive-reader.ts
+var MAX_EVENT_SIZE = 10 * 1024 * 1024;
+var SessionArchiveReader = class {
+  /** Reads only the metadata header from an archive. */
+  readMetadata(compressed) {
+    const data = gunzipSync(compressed);
+    const metaLen = data.readUInt32BE(0);
+    const metaJson = data.subarray(4, 4 + metaLen).toString("utf-8");
+    const metadata = JSON.parse(metaJson);
+    if (metadata.version !== CURRENT_VERSION) {
+      throw new Error(`Unsupported archive version: ${metadata.version} (expected ${CURRENT_VERSION})`);
+    }
+    return metadata;
+  }
+  /** Reads the full archive: metadata + all events into a DebugEventStore. */
+  readFull(compressed) {
+    const data = gunzipSync(compressed);
+    let offset = 0;
+    const metaLen = data.readUInt32BE(offset);
+    offset += 4;
+    const metaJson = data.subarray(offset, offset + metaLen).toString("utf-8");
+    offset += metaLen;
+    const metadata = JSON.parse(metaJson);
+    if (metadata.version !== CURRENT_VERSION) {
+      throw new Error(`Unsupported archive version: ${metadata.version} (expected ${CURRENT_VERSION})`);
+    }
+    const eventStore = new DebugEventStore(metadata.sessionId, Number.MAX_SAFE_INTEGER);
+    while (offset < data.length) {
+      if (offset + 4 > data.length) break;
+      const eventLen = data.readUInt32BE(offset);
+      offset += 4;
+      if (eventLen <= 0 || eventLen > MAX_EVENT_SIZE) {
+        throw new Error(`Invalid event size: ${eventLen}`);
+      }
+      if (offset + eventLen > data.length) break;
+      const eventJson = data.subarray(offset, offset + eventLen).toString("utf-8");
+      offset += eventLen;
+      const eventInfo = JSON.parse(eventJson);
+      const netEvent = eventInfoToNetEvent(eventInfo);
+      eventStore.append(netEvent);
+    }
+    return { metadata, eventStore };
+  }
+};
+function eventInfoToNetEvent(info) {
+  const timestamp = new Date(info.timestamp).getTime();
+  const d = info.details;
+  switch (info.type) {
+    case "ExecutionStarted":
+      return { type: "execution-started", timestamp, netName: d["netName"], executionId: d["executionId"] };
+    case "ExecutionCompleted":
+      return { type: "execution-completed", timestamp, netName: d["netName"], executionId: d["executionId"], totalDurationMs: d["totalDurationMs"] };
+    case "TransitionEnabled":
+      return { type: "transition-enabled", timestamp, transitionName: info.transitionName };
+    case "TransitionClockRestarted":
+      return { type: "transition-clock-restarted", timestamp, transitionName: info.transitionName };
+    case "TransitionStarted": {
+      const tokens = d["consumedTokens"].map((t) => infoToToken(t));
+      return { type: "transition-started", timestamp, transitionName: info.transitionName, consumedTokens: tokens };
+    }
+    case "TransitionCompleted": {
+      const tokens = d["producedTokens"].map((t) => infoToToken(t));
+      return { type: "transition-completed", timestamp, transitionName: info.transitionName, producedTokens: tokens, durationMs: d["durationMs"] };
+    }
+    case "TransitionFailed":
+      return { type: "transition-failed", timestamp, transitionName: info.transitionName, errorMessage: d["errorMessage"], exceptionType: d["exceptionType"] };
+    case "TransitionTimedOut":
+      return { type: "transition-timed-out", timestamp, transitionName: info.transitionName, deadlineMs: d["deadlineMs"], actualDurationMs: d["actualDurationMs"] };
+    case "ActionTimedOut":
+      return { type: "action-timed-out", timestamp, transitionName: info.transitionName, timeoutMs: d["timeoutMs"] };
+    case "TokenAdded": {
+      const t = d["token"];
+      return { type: "token-added", timestamp, placeName: info.placeName, token: infoToToken(t) };
+    }
+    case "TokenRemoved": {
+      const t = d["token"];
+      return { type: "token-removed", timestamp, placeName: info.placeName, token: infoToToken(t) };
+    }
+    case "MarkingSnapshot": {
+      const markingData = d["marking"];
+      const marking = /* @__PURE__ */ new Map();
+      for (const [place, tokens] of Object.entries(markingData)) {
+        marking.set(place, tokens.map((t) => infoToToken(t)));
+      }
+      return { type: "marking-snapshot", timestamp, marking };
+    }
+    case "LogMessage":
+      return {
+        type: "log-message",
+        timestamp,
+        transitionName: info.transitionName,
+        logger: d["loggerName"],
+        level: d["level"],
+        message: d["message"],
+        error: d["throwable"] ?? null,
+        errorMessage: d["throwableMessage"] ?? null
+      };
+    default:
+      return { type: "transition-enabled", timestamp, transitionName: info.transitionName ?? "unknown" };
+  }
+}
+function infoToToken(t) {
+  return {
+    value: t.value,
+    createdAt: t.timestamp ? new Date(t.timestamp).getTime() : Date.now()
+  };
+}
+
+// src/debug/place-analysis.ts
+var PlaceAnalysis = class _PlaceAnalysis {
+  _data;
+  constructor(data) {
+    this._data = data;
+  }
+  get data() {
+    return this._data;
+  }
+  isStart(placeName) {
+    const info = this._data.get(placeName);
+    return info != null && !info.hasIncoming;
+  }
+  isEnd(placeName) {
+    const info = this._data.get(placeName);
+    return info != null && !info.hasOutgoing;
+  }
+  /** Build place analysis from a PetriNet. */
+  static from(net) {
+    const data = /* @__PURE__ */ new Map();
+    function ensure(place) {
+      let info = data.get(place.name);
+      if (!info) {
+        info = { tokenType: "unknown", hasIncoming: false, hasOutgoing: false };
+        data.set(place.name, info);
+      }
+      return info;
+    }
+    for (const transition of net.transitions) {
+      for (const input of transition.inputSpecs) {
+        const info = ensure(input.place);
+        info.hasOutgoing = true;
+      }
+      if (transition.outputSpec) {
+        const outputPlaces = collectOutputPlaces(transition.outputSpec);
+        for (const place of outputPlaces) {
+          const info = ensure(place);
+          info.hasIncoming = true;
+        }
+      }
+      for (const inh of transition.inhibitors) {
+        ensure(inh.place);
+      }
+      for (const read of transition.reads) {
+        const info = ensure(read.place);
+        info.hasOutgoing = true;
+      }
+      for (const reset of transition.resets) {
+        ensure(reset.place);
+      }
+    }
+    return new _PlaceAnalysis(data);
+  }
+};
+function collectOutputPlaces(out) {
+  const spec = out;
+  switch (spec.type) {
+    case "place":
+      return spec.place ? [spec.place] : [];
+    case "and":
+    case "xor":
+      return (spec.children ?? []).flatMap((c) => collectOutputPlaces(c));
+    case "timeout":
+      return spec.child ? collectOutputPlaces(spec.child) : [];
+    case "forward-input":
+      return spec.to ? [spec.to] : [];
+    default:
+      return [];
+  }
+}
+
 // src/debug/debug-session-registry.ts
 function buildNetStructure(session) {
   if (session.importedStructure) {
@@ -562,9 +676,11 @@ function convertMarking(marking, compact = false) {
 var BATCH_SIZE = 500;
 var DebugProtocolHandler = class {
   _sessionRegistry;
+  _archiveStorage;
   _clients = /* @__PURE__ */ new Map();
-  constructor(sessionRegistry) {
+  constructor(sessionRegistry, archiveStorage) {
     this._sessionRegistry = sessionRegistry;
+    this._archiveStorage = archiveStorage ?? null;
   }
   /** Registers a new client connection. */
   clientConnected(clientId, sink) {
@@ -621,6 +737,15 @@ var DebugProtocolHandler = class {
         case "listBreakpoints":
           this.handleListBreakpoints(clientState, command);
           break;
+        case "listArchives":
+          this.handleListArchives(clientState, command);
+          break;
+        case "importArchive":
+          this.handleImportArchive(clientState, command);
+          break;
+        case "uploadArchive":
+          this.handleUploadArchive(clientState, command);
+          break;
       }
     } catch (e) {
       this.sendError(clientState, "COMMAND_ERROR", e instanceof Error ? e.message : String(e), null);
@@ -823,6 +948,97 @@ var DebugProtocolHandler = class {
     const breakpoints = client.subscriptions.getBreakpoints(cmd.sessionId);
     this.send(client, { type: "breakpointList", sessionId: cmd.sessionId, breakpoints });
   }
+  // ======================== Archive Handlers ========================
+  async handleListArchives(client, cmd) {
+    if (!this._archiveStorage || !this._archiveStorage.isAvailable()) {
+      this.send(client, { type: "archiveList", archives: [], storageAvailable: false });
+      return;
+    }
+    try {
+      const limit = cmd.limit ?? 50;
+      const archived = await this._archiveStorage.list(limit, cmd.prefix);
+      const summaries = archived.map((a) => ({
+        sessionId: a.sessionId,
+        key: a.key,
+        sizeBytes: a.sizeBytes,
+        lastModified: new Date(a.lastModified).toISOString()
+      }));
+      this.send(client, { type: "archiveList", archives: summaries, storageAvailable: true });
+    } catch (e) {
+      this.sendError(client, "ARCHIVE_LIST_ERROR", e instanceof Error ? e.message : String(e), null);
+    }
+  }
+  async handleImportArchive(client, cmd) {
+    if (!this._archiveStorage || !this._archiveStorage.isAvailable()) {
+      this.sendError(client, "NO_ARCHIVE_STORAGE", "Archive storage is not configured", null);
+      return;
+    }
+    try {
+      const data = await this._archiveStorage.retrieve(cmd.sessionId);
+      const reader = new SessionArchiveReader();
+      const imported = reader.readFull(data);
+      const meta = imported.metadata;
+      this._sessionRegistry.registerImported(
+        meta.sessionId,
+        meta.netName,
+        meta.dotDiagram,
+        meta.structure,
+        imported.eventStore,
+        new Date(meta.startTime).getTime()
+      );
+      this.send(client, {
+        type: "archiveImported",
+        sessionId: meta.sessionId,
+        netName: meta.netName,
+        eventCount: meta.eventCount
+      });
+      this.broadcastSessionList();
+    } catch (e) {
+      this.sendError(client, "ARCHIVE_IMPORT_ERROR", e instanceof Error ? e.message : String(e), cmd.sessionId);
+    }
+  }
+  async handleUploadArchive(client, cmd) {
+    try {
+      const decoded = Buffer.from(cmd.data, "base64");
+      const reader = new SessionArchiveReader();
+      const imported = reader.readFull(decoded);
+      const meta = imported.metadata;
+      this._sessionRegistry.registerImported(
+        meta.sessionId,
+        meta.netName,
+        meta.dotDiagram,
+        meta.structure,
+        imported.eventStore,
+        new Date(meta.startTime).getTime()
+      );
+      this.send(client, {
+        type: "archiveImported",
+        sessionId: meta.sessionId,
+        netName: meta.netName,
+        eventCount: meta.eventCount
+      });
+      this.broadcastSessionList();
+    } catch (e) {
+      this.sendError(client, "ARCHIVE_UPLOAD_ERROR", e instanceof Error ? e.message : String(e), null);
+    }
+  }
+  broadcastSessionList() {
+    const sessions = this._sessionRegistry.listSessions(50);
+    const summaries = sessions.map((s) => ({
+      sessionId: s.sessionId,
+      netName: s.netName,
+      startTime: new Date(s.startTime).toISOString(),
+      active: s.active,
+      eventCount: s.eventStore.eventCount()
+    }));
+    const response = { type: "sessionList", sessions: summaries };
+    for (const clientState of this._clients.values()) {
+      try {
+        this.send(clientState, response);
+      } catch {
+      }
+    }
+  }
   // ======================== Helper Methods ========================
   send(client, response) {
     client.sink(response);
@@ -1112,9 +1328,6 @@ var DebugAwareEventStore = class {
   }
 };
 
-// src/debug/archive/session-archive.ts
-var CURRENT_VERSION = 1;
-
 // src/debug/archive/file-session-archive-storage.ts
 import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
 import { join, normalize, resolve } from "path";
@@ -1246,115 +1459,6 @@ var SessionArchiveWriter = class {
   }
 };
 
-// src/debug/archive/session-archive-reader.ts
-import { gunzipSync } from "zlib";
-var MAX_EVENT_SIZE = 10 * 1024 * 1024;
-var SessionArchiveReader = class {
-  /** Reads only the metadata header from an archive. */
-  readMetadata(compressed) {
-    const data = gunzipSync(compressed);
-    const metaLen = data.readUInt32BE(0);
-    const metaJson = data.subarray(4, 4 + metaLen).toString("utf-8");
-    const metadata = JSON.parse(metaJson);
-    if (metadata.version !== CURRENT_VERSION) {
-      throw new Error(`Unsupported archive version: ${metadata.version} (expected ${CURRENT_VERSION})`);
-    }
-    return metadata;
-  }
-  /** Reads the full archive: metadata + all events into a DebugEventStore. */
-  readFull(compressed) {
-    const data = gunzipSync(compressed);
-    let offset = 0;
-    const metaLen = data.readUInt32BE(offset);
-    offset += 4;
-    const metaJson = data.subarray(offset, offset + metaLen).toString("utf-8");
-    offset += metaLen;
-    const metadata = JSON.parse(metaJson);
-    if (metadata.version !== CURRENT_VERSION) {
-      throw new Error(`Unsupported archive version: ${metadata.version} (expected ${CURRENT_VERSION})`);
-    }
-    const eventStore = new DebugEventStore(metadata.sessionId, Number.MAX_SAFE_INTEGER);
-    while (offset < data.length) {
-      if (offset + 4 > data.length) break;
-      const eventLen = data.readUInt32BE(offset);
-      offset += 4;
-      if (eventLen <= 0 || eventLen > MAX_EVENT_SIZE) {
-        throw new Error(`Invalid event size: ${eventLen}`);
-      }
-      if (offset + eventLen > data.length) break;
-      const eventJson = data.subarray(offset, offset + eventLen).toString("utf-8");
-      offset += eventLen;
-      const eventInfo = JSON.parse(eventJson);
-      const netEvent = eventInfoToNetEvent(eventInfo);
-      eventStore.append(netEvent);
-    }
-    return { metadata, eventStore };
-  }
-};
-function eventInfoToNetEvent(info) {
-  const timestamp = new Date(info.timestamp).getTime();
-  const d = info.details;
-  switch (info.type) {
-    case "ExecutionStarted":
-      return { type: "execution-started", timestamp, netName: d["netName"], executionId: d["executionId"] };
-    case "ExecutionCompleted":
-      return { type: "execution-completed", timestamp, netName: d["netName"], executionId: d["executionId"], totalDurationMs: d["totalDurationMs"] };
-    case "TransitionEnabled":
-      return { type: "transition-enabled", timestamp, transitionName: info.transitionName };
-    case "TransitionClockRestarted":
-      return { type: "transition-clock-restarted", timestamp, transitionName: info.transitionName };
-    case "TransitionStarted": {
-      const tokens = d["consumedTokens"].map((t) => infoToToken(t));
-      return { type: "transition-started", timestamp, transitionName: info.transitionName, consumedTokens: tokens };
-    }
-    case "TransitionCompleted": {
-      const tokens = d["producedTokens"].map((t) => infoToToken(t));
-      return { type: "transition-completed", timestamp, transitionName: info.transitionName, producedTokens: tokens, durationMs: d["durationMs"] };
-    }
-    case "TransitionFailed":
-      return { type: "transition-failed", timestamp, transitionName: info.transitionName, errorMessage: d["errorMessage"], exceptionType: d["exceptionType"] };
-    case "TransitionTimedOut":
-      return { type: "transition-timed-out", timestamp, transitionName: info.transitionName, deadlineMs: d["deadlineMs"], actualDurationMs: d["actualDurationMs"] };
-    case "ActionTimedOut":
-      return { type: "action-timed-out", timestamp, transitionName: info.transitionName, timeoutMs: d["timeoutMs"] };
-    case "TokenAdded": {
-      const t = d["token"];
-      return { type: "token-added", timestamp, placeName: info.placeName, token: infoToToken(t) };
-    }
-    case "TokenRemoved": {
-      const t = d["token"];
-      return { type: "token-removed", timestamp, placeName: info.placeName, token: infoToToken(t) };
-    }
-    case "MarkingSnapshot": {
-      const markingData = d["marking"];
-      const marking = /* @__PURE__ */ new Map();
-      for (const [place, tokens] of Object.entries(markingData)) {
-        marking.set(place, tokens.map((t) => infoToToken(t)));
-      }
-      return { type: "marking-snapshot", timestamp, marking };
-    }
-    case "LogMessage":
-      return {
-        type: "log-message",
-        timestamp,
-        transitionName: info.transitionName,
-        logger: d["loggerName"],
-        level: d["level"],
-        message: d["message"],
-        error: d["throwable"] ?? null,
-        errorMessage: d["throwableMessage"] ?? null
-      };
-    default:
-      return { type: "transition-enabled", timestamp, transitionName: info.transitionName ?? "unknown" };
-  }
-}
-function infoToToken(t) {
-  return {
-    value: t.value,
-    createdAt: t.timestamp ? new Date(t.timestamp).getTime() : Date.now()
-  };
-}
-
 // src/debug/index.ts
 async function debugUiAssetPath() {
   const dynamicImport = Function("m", "return import(m)");