@cortexkit/aft-opencode 0.36.0 → 0.37.0

package/src/shared/rpc-client.ts

@@ -1,18 +1,28 @@
 import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { warn } from "../logger";
-import { rpcPortFileDir, rpcPortFilePath } from "./rpc-utils";
+import { isPidAlive, parseRpcPortRecord, rpcPortFileDir, rpcPortFilePath } from "./rpc-utils";
 
 const MAX_RETRIES = 10;
 const RETRY_DELAY_MS = 500;
 const REQUEST_TIMEOUT_MS = 5000;
 
 type PortInfoSource = "instance" | "legacy";
-type ParsedPortInfo = { port: number; token: string | null };
+type ParsedPortInfo = { port: number; token: string | null; pid?: number; started_at?: number };
 type PortInfo = ParsedPortInfo & { source: PortInfoSource; path?: string };
 
 export interface AftRpcCallOptions {
   signal?: AbortSignal;
+  /**
+   * Optional gate over WARM (non-placeholder) responses. With multiple RPC
+   * servers alive for one project hash (multi-project hosts, stale long-lived
+   * processes), a warm response can describe ANOTHER project's bridge
+   * (cross-project contamination). Return false to skip that response and
+   * keep trying other ports instead of returning it — so a stray server can't
+   * mask the right one. Skipped responses are never cached as the good port
+   * and never returned; if only strays and placeholders answer, the
+   * placeholder wins.
+   */
+  accept?: (result: unknown) => boolean;
 }
 
 function abortError(signal: AbortSignal): Error {
@@ -83,6 +93,11 @@ export class AftRpcClient {
           placeholder = result; // remember but keep trying
           continue;
         }
+        if (options.accept && !options.accept(result)) {
+          // Stray warm response (e.g. another project's data) — skip it and
+          // keep scanning so it can't mask the right server.
+          continue;
+        }
         // Warm response — cache this port for subsequent calls.
         this.port = info.port;
         this.token = info.token;
@@ -155,7 +170,7 @@ export class AftRpcClient {
         const alive: PortInfo[] = [];
         for (const info of infos) {
           throwIfAborted(signal);
-          if (await this.healthCheck(info.port, signal)) {
+          if (await this.healthCheck(info.port, info.pid, signal)) {
             this.clearPortFailure(info);
             alive.push(info);
           } else {
@@ -180,16 +195,39 @@ export class AftRpcClient {
       collected.push(info);
     };
 
-    // Per-instance directory (v0.28.2+): one file per plugin load.
+    // Per-instance directory (v0.28.2+): one file per plugin load. Each file now
+    // records the owning process pid; we skip (and reclaim) any whose process is
+    // dead so a poll doesn't wade through crash/restart leftovers, and we order
+    // newest-first so the freshest live server wins the port de-dupe (a stale
+    // file naming a reused port can no longer mask a fresh one with its old token).
     if (existsSync(this.portsDir)) {
       try {
-        const entries = readdirSync(this.portsDir).sort();
-        for (const entry of entries) {
+        const live: PortInfo[] = [];
+        for (const entry of readdirSync(this.portsDir)) {
           if (!entry.endsWith(".json")) continue;
           const filePath = join(this.portsDir, entry);
           const info = this.parsePortFile(filePath);
-          if (info) add({ ...info, source: "instance", path: filePath });
+          if (!info) continue;
+          // Only reclaim when we can PROVE the owner is dead (pid present and not
+          // alive). Files without a pid (older format) are kept and fall through
+          // to the health check, since we can't prove they're dead.
+          if (info.pid !== undefined && !isPidAlive(info.pid)) {
+            this.reclaimDeadPortFile(filePath);
+            continue;
+          }
+          live.push({ ...info, source: "instance", path: filePath });
         }
+        // Newest first: files with a started_at sort before those without.
+        // Break ties deterministically (equal/absent started_at) by pid then
+        // port so selection is stable across reads rather than depending on
+        // directory iteration order.
+        live.sort(
+          (a, b) =>
+            (b.started_at ?? 0) - (a.started_at ?? 0) ||
+            (b.pid ?? 0) - (a.pid ?? 0) ||
+            (b.port ?? 0) - (a.port ?? 0),
+        );
+        for (const info of live) add(info);
       } catch {
         // ignore read errors
       }
@@ -204,24 +242,19 @@ export class AftRpcClient {
     return collected;
   }
 
+  /** Delete a port file whose owning process is provably dead (best-effort). */
+  private reclaimDeadPortFile(filePath: string): void {
+    try {
+      unlinkSync(filePath);
+    } catch {
+      // best-effort; a concurrent writer may have already replaced it
+    }
+  }
+
   private parsePortFile(filePath: string): ParsedPortInfo | null {
     try {
-      const content = readFileSync(filePath, "utf-8").trim();
-      let port: number;
-      let token: string | null;
-      if (content.startsWith("{")) {
-        const parsed = JSON.parse(content) as { port?: unknown; token?: unknown };
-        port = typeof parsed.port === "number" ? parsed.port : Number.NaN;
-        token = typeof parsed.token === "string" ? parsed.token : null;
-      } else {
-        warn("RPC port file uses legacy integer format; unauthenticated RPC is deprecated");
-        port = Number.parseInt(content, 10);
-        token = null;
-      }
-      if (Number.isNaN(port) || port <= 0 || port > 65535) {
-        return null;
-      }
-      return { port, token };
+      const content = readFileSync(filePath, "utf-8");
+      return parseRpcPortRecord(content);
     } catch {
       return null;
     }
@@ -259,14 +292,34 @@ export class AftRpcClient {
     }
   }
 
-  private async healthCheck(port: number, signal?: AbortSignal): Promise<boolean> {
+  private async healthCheck(
+    port: number,
+    expectedPid: number | undefined,
+    signal?: AbortSignal,
+  ): Promise<boolean> {
     try {
       const response = await this.fetchWithTimeout(
         `http://127.0.0.1:${port}/health`,
         { method: "GET" },
         signal,
       );
-      return response.ok;
+      if (!response.ok) return false;
+      // Identity check: the port file records the owning pid and `/health`
+      // echoes the live server's pid. If they disagree, the port was recycled
+      // by a *different* AFT server (or an unrelated localhost service that
+      // happens to answer /health), so this port file is stale — reject it so
+      // we don't POST this file's token to the wrong server. Only enforced when
+      // both sides expose a pid (older port files omit it).
+      if (expectedPid !== undefined) {
+        try {
+          const body = (await response.json()) as { pid?: unknown };
+          if (typeof body?.pid === "number" && body.pid !== expectedPid) return false;
+        } catch {
+          // Non-JSON / unexpected body: not a healthy AFT server we trust.
+          return false;
+        }
+      }
+      return true;
     } catch {
       throwIfAborted(signal);
       return false;

package/src/shared/rpc-server.ts

@@ -1,9 +1,16 @@
 import { randomBytes } from "node:crypto";
-import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { dirname, join } from "node:path";
 import { log, warn } from "../logger";
-import { rpcPortFileDir } from "./rpc-utils";
+import { isPidAlive, parseRpcPortRecord, rpcPortFileDir } from "./rpc-utils";
 
 type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
 
@@ -53,12 +60,28 @@ export class AftRpcServer {
           const dir = dirname(this.portFilePath);
           mkdirSync(dir, { recursive: true, mode: 0o700 });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync(tmpPath, JSON.stringify({ port: this.port, token: this.token }), {
-            encoding: "utf-8",
-            mode: 0o600,
-          });
+          // Record pid + started_at so the client can skip files whose owning
+          // process is dead (without a health-check round-trip) and prefer the
+          // freshest live server, instead of accumulating crash/restart leftovers.
+          writeFileSync(
+            tmpPath,
+            JSON.stringify({
+              port: this.port,
+              token: this.token,
+              pid: process.pid,
+              started_at: Date.now(),
+            }),
+            { encoding: "utf-8", mode: 0o600 },
+          );
           renameSync(tmpPath, this.portFilePath);
           log(`RPC server listening on 127.0.0.1:${this.port}`);
+          // Hygiene: sweep dead siblings while we're here. The client only
+          // reclaims dead-pid files on a cold port scan, and it caches the
+          // first warm port afterwards — so crash/restart leftovers piled up
+          // (dozens of dead files per project hash were observed). Server
+          // startup is the natural sweep point: it runs once per instance and
+          // already owns this directory.
+          this.sweepDeadPortFiles();
         } catch (err) {
           warn(`Failed to write RPC port file: ${err}`);
         }
@@ -71,6 +94,41 @@ export class AftRpcServer {
     });
   }
 
+  /**
+   * Remove sibling port files whose owning process is provably dead.
+   * Only files with a recorded pid that no longer maps to a live process are
+   * removed; pid-less (legacy) files and live entries are left untouched.
+   * Never touches our own freshly written file.
+   */
+  private sweepDeadPortFiles(): void {
+    let entries: string[];
+    try {
+      entries = readdirSync(this.portsDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const filePath = join(this.portsDir, entry);
+      if (filePath === this.portFilePath) continue;
+      try {
+        const record = parseRpcPortRecord(readFileSync(filePath, "utf-8"));
+        // Unparsable file: stale tmp/corrupt leftover — remove. Parsable but
+        // pid-less (legacy): keep, we cannot prove the owner is dead.
+        if (record === null) {
+          unlinkSync(filePath);
+          continue;
+        }
+        if (record.pid !== undefined && !isPidAlive(record.pid)) {
+          unlinkSync(filePath);
+        }
+      } catch {
+        // Racing another instance's sweep or hitting a permission issue is
+        // fine — the file will be retried on the next server start.
+      }
+    }
+  }
+
   /** Stop the server and clean up port file. */
   stop(): void {
     if (this.server) {

package/src/shared/rpc-utils.ts

@@ -41,3 +41,65 @@ export function rpcPortFileDir(storageDir: string, directory: string): string {
   const hash = projectHash(directory);
   return join(storageDir, "rpc", hash, "ports");
 }
+
+/**
+ * Contents of a per-instance RPC port file. `pid` + `started_at` let the client
+ * skip files whose owning process is dead (no health-check round-trip) and pick
+ * the freshest live server, instead of wading through every crash/restart
+ * leftover. Older files carry only `{ port, token }` (no pid); those are treated
+ * as "can't prove dead" and fall back to the health-check path.
+ */
+export interface RpcPortRecord {
+  port: number;
+  token: string | null;
+  /** PID of the plugin process that owns this server, if recorded. */
+  pid?: number;
+  /** `Date.now()` when this server started, for newest-first ordering. */
+  started_at?: number;
+}
+
+/** True if `pid` names a live process. `process.kill(pid, 0)` sends no signal. */
+export function isPidAlive(pid: number | undefined): boolean {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM = process exists but we can't signal it (still alive).
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/**
+ * Parse a port file's contents into a record. Accepts the current JSON shape
+ * (`{ port, token, pid?, started_at? }`) and the legacy bare-integer format
+ * (unauthenticated, pre-v0.28.2). Returns `null` for unusable contents.
+ */
+export function parseRpcPortRecord(content: string): RpcPortRecord | null {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed) as {
+        port?: unknown;
+        token?: unknown;
+        pid?: unknown;
+        started_at?: unknown;
+      };
+      const port = typeof parsed.port === "number" ? parsed.port : Number.NaN;
+      if (!Number.isInteger(port) || port <= 0 || port > 65535) return null;
+      return {
+        port,
+        token: typeof parsed.token === "string" ? parsed.token : null,
+        pid:
+          typeof parsed.pid === "number" && Number.isInteger(parsed.pid) ? parsed.pid : undefined,
+        started_at: typeof parsed.started_at === "number" ? parsed.started_at : undefined,
+      };
+    } catch {
+      return null;
+    }
+  }
+  const port = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return null;
+  return { port, token: null };
+}

package/src/shared/session-directory.ts

@@ -152,7 +152,63 @@ export function warmSessionDirectory(
   void getSessionDirectory(client, sessionId, fallbackDirectory);
 }
 
+/**
+ * Serve-time verification for cross-project bridge resolution.
+ *
+ * The RPC status handler may serve a bridge for a DIFFERENT project root than
+ * the requesting instance's own directory (the `opencode -s` resume case).
+ * That cross-directory path must never trust a possibly-stale cache entry:
+ * a wrong mapping makes the sidebar render another project's data (RPC
+ * contamination). This helper re-resolves the session's directory via a
+ * fresh SDK lookup and only returns a directory the SDK confirms RIGHT NOW.
+ *
+ * Results are memoized briefly (VERIFY_TTL_MS) so a 1.5s sidebar poll doesn't
+ * hammer the SDK; the TTL is short enough that stale mappings die quickly.
+ * Returns `null` when the lookup fails or the SDK reports no directory —
+ * callers must treat that as "do not serve cross-project data".
+ */
+const VERIFY_TTL_MS = 15_000;
+const verifyCache = new Map<string, { directory: string | null; verifiedAt: number }>();
+
+export async function verifySessionDirectory(
+  client: unknown,
+  sessionId: string,
+): Promise<string | null> {
+  if (!sessionId) return null;
+  const hit = verifyCache.get(sessionId);
+  if (hit && Date.now() - hit.verifiedAt < VERIFY_TTL_MS) return hit.directory;
+
+  const c = client as OpenCodeClientShape;
+  const sessionApi = c?.session;
+  if (!sessionApi || typeof sessionApi.get !== "function") return null;
+
+  let dir: string | null = null;
+  try {
+    const result = await sessionApi.get({ path: { id: sessionId } });
+    const session: SessionInfo | undefined =
+      (result as { data?: SessionInfo } | undefined)?.data ?? (result as SessionInfo | undefined);
+    if (session && typeof session.directory === "string" && session.directory.length > 0) {
+      dir = session.directory;
+    }
+  } catch {
+    // Verification failure = do not serve cross-project data. Do NOT memoize
+    // failures: the next poll should retry (transient SDK errors must not
+    // stick the sidebar on placeholder for the TTL window).
+    return null;
+  }
+
+  verifyCache.set(sessionId, { directory: dir, verifiedAt: Date.now() });
+  if (verifyCache.size > CACHE_MAX_ENTRIES) {
+    const oldest = verifyCache.keys().next().value;
+    if (oldest !== undefined) verifyCache.delete(oldest);
+  }
+  // Keep the long-lived cache coherent with what the SDK just said.
+  if (dir !== null) setCache(sessionId, dir);
+  return dir;
+}
+
 /** Test-only: clear the cache between unit tests. */
 export function _resetSessionDirectoryCacheForTest(): void {
   cache.clear();
+  verifyCache.clear();
 }

package/src/tui/index.tsx

@@ -16,6 +16,7 @@ import {
 import {
   createAftSidebarSlot,
   formatCompressionSidebarRows,
+  isSnapshotForContext,
   resolveTuiStorageDir,
   shouldSuppressUninitializedDowngrade,
 } from "./sidebar";
@@ -128,12 +129,30 @@ const R = (props: {
 interface StatusDialogProps {
   api: TuiPluginApi;
   client: AftRpcClient;
+  directory: string;
   sessionID: string;
   initial: AftStatusSnapshot | null;
   initialError: string | null;
   onClose: () => void;
 }
 
+/**
+ * Shared accept-gate for status RPC calls: skip warm responses that describe
+ * another project (cross-project contamination from multi-project hosts —
+ * see isSnapshotForContext) so they can't beat the right server's response.
+ */
+function statusAcceptGate(directory: string): (result: unknown) => boolean {
+  return (result) => {
+    const rec = result as Record<string, unknown>;
+    if (rec?.success === false) return true; // error envelopes handled by callers
+    return isSnapshotForContext(
+      coerceAftStatus(rec),
+      directory,
+      rec?.served_directory as string | undefined,
+    );
+  };
+}
+
 const StatusDialog = (props: StatusDialogProps) => {
   const theme = createMemo(() => (props.api as any).theme.current as TuiThemeCurrent);
   const t = () => theme();
@@ -157,7 +176,7 @@ const StatusDialog = (props: StatusDialogProps) => {
       const response = await props.client.call(
         "status",
         { sessionID: props.sessionID },
-        { signal: controller.signal },
+        { signal: controller.signal, accept: statusAcceptGate(props.directory) },
       );
       if (controller.signal.aborted || requestGeneration !== pollGeneration) return;
       if ((response as Record<string, unknown>).success !== false) {
@@ -545,7 +564,11 @@ async function showStatusDialog(api: TuiPluginApi): Promise<void> {
   let initial: AftStatusSnapshot | null = null;
   let initialError: string | null = null;
   try {
-    const response = await client.call("status", { sessionID });
+    const response = await client.call(
+      "status",
+      { sessionID },
+      { accept: statusAcceptGate(directory) },
+    );
     if ((response as Record<string, unknown>).success !== false) {
       initial = coerceAftStatus(response as Record<string, unknown>);
     } else {
@@ -561,6 +584,7 @@ async function showStatusDialog(api: TuiPluginApi): Promise<void> {
       <StatusDialog
         api={api}
         client={client}
+        directory={directory}
         sessionID={sessionID}
         initial={initial}
         initialError={initialError}

package/src/tui/sidebar.tsx

@@ -259,6 +259,49 @@ export function shouldSuppressUninitializedDowngrade(
   return incomingCacheRole === "not_initialized" && haveInitializedForContext;
 }
 
+/**
+ * Cross-project contamination belt. The RPC layer can hand back a snapshot
+ * describing a DIFFERENT project than the one this sidebar asked about — a
+ * multi-project host (Desktop / `opencode serve`) whose status handler
+ * resolved another project's warm bridge, including long-lived processes
+ * still running pre-fix plugin code. Rendering it shows another repo's
+ * indexes/health in this window.
+ *
+ * A mismatched project_root is acceptable ONLY when the serving handler says
+ * it resolved that directory DELIBERATELY: new servers attach
+ * `served_directory` (their own cwd, or the SDK-verified `opencode -s` resume
+ * directory) to every status response. That marker is handler-attached
+ * provenance — it cannot be faked by snapshot contents. We explicitly do NOT
+ * use `snapshot.session.id` here: Rust echoes the REQUESTED session id into
+ * the snapshot, so it matches even when the data came from another project's
+ * bridge (the hole that let contamination through this belt's first version).
+ *
+ * Rules:
+ *  - placeholder/synthetic snapshots (no project_root) → accept (not data)
+ *  - project_root (or canonical_root) matches the sidebar directory → accept
+ *  - mismatched root AND served_directory matches a snapshot root → accept
+ *    (deliberate, SDK-verified resume serve from a new server)
+ *  - otherwise → reject (stray; includes everything old servers cross-serve)
+ */
+export function isSnapshotForContext(
+  snapshot: AftStatusSnapshot,
+  directory: string,
+  servedDirectory: string | undefined,
+): boolean {
+  const stripSlash = (p: string) => p.replace(/\/+$/, "");
+  const roots = [snapshot.project_root, snapshot.canonical_root].filter(
+    (r): r is string => typeof r === "string" && r.length > 0,
+  );
+  if (roots.length === 0) return true; // placeholder / synthetic
+  const dir = stripSlash(directory);
+  if (roots.some((r) => stripSlash(r) === dir)) return true;
+  if (typeof servedDirectory === "string" && servedDirectory.length > 0) {
+    const served = stripSlash(servedDirectory);
+    return roots.some((r) => stripSlash(r) === served);
+  }
+  return false;
+}
+
 const SidebarContent = (props: {
   api: TuiPluginApi;
   sessionID: () => string;
@@ -330,12 +373,32 @@ const SidebarContent = (props: {
       const response = await client.call(
         "status",
         { sessionID: sid },
-        { signal: controller.signal },
+        {
+          signal: controller.signal,
+          // With several RPC servers alive for this project hash, a stray
+          // warm response (another project's bridge) must not beat the right
+          // server or the placeholder — skip it at the port-scan level.
+          accept: (result) => {
+            const rec = result as Record<string, unknown>;
+            if (rec?.success === false) return true; // errors handled below
+            return isSnapshotForContext(
+              coerceAftStatus(rec),
+              directory,
+              rec?.served_directory as string | undefined,
+            );
+          },
+        },
       );
       if (controller.signal.aborted || requestGeneration !== generation) return;
       if (currentDirectory() !== directory || props.sessionID() !== sid) return;
       if (response && (response as Record<string, unknown>).success !== false) {
         const snapshot = coerceAftStatus(response as Record<string, unknown>);
+        // Belt: never render a snapshot describing another project (see
+        // isSnapshotForContext). Keep whatever we currently show instead.
+        const servedDirectory = (response as Record<string, unknown>).served_directory as
+          | string
+          | undefined;
+        if (!isSnapshotForContext(snapshot, directory, servedDirectory)) return;
         // Stale-while-revalidate: keep the last-good snapshot instead of
         // flickering to the lazy-bridge placeholder on a transient
         // not_initialized. See shouldSuppressUninitializedDowngrade.

package/dist/metadata-store.d.ts

@@ -1,29 +0,0 @@
-/**
- * Pending tool metadata store.
- *
- * OpenCode's `fromPlugin()` wrapper always replaces plugin metadata with
- * `{ truncated, outputPath }`, discarding title and custom metadata.
- *
- * This store captures metadata during execute(), then the `tool.execute.after`
- * hook consumes it and merges it back before the final part is written.
- *
- * Flow:
- *   execute() → storeToolMetadata(sessionID, callID, data)
- *   fromPlugin() → overwrites metadata with { truncated }
- *   tool.execute.after → consumeToolMetadata(sessionID, callID) → merges back
- */
-export interface PendingToolMetadata {
-    title?: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Store metadata to be restored after fromPlugin() overwrites it.
- * Called from tool execute() functions.
- */
-export declare function storeToolMetadata(sessionID: string, callID: string, data: PendingToolMetadata): void;
-/**
- * Consume stored metadata (one-time read, removes from store).
- * Called from tool.execute.after hook.
- */
-export declare function consumeToolMetadata(sessionID: string, callID: string): PendingToolMetadata | undefined;
-//# sourceMappingURL=metadata-store.d.ts.map

package/dist/metadata-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadata-store.d.ts","sourceRoot":"","sources":["../src/metadata-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAmBD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,mBAAmB,GACxB,IAAI,CAMN;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,mBAAmB,GAAG,SAAS,CASjC"}

package/dist/tools/structure.d.ts

@@ -1,8 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin";
-import type { PluginContext } from "../types.js";
-/**
- * Tool definitions for scope-aware structure commands:
- * add_member, add_derive, wrap_try_catch, add_decorator, add_struct_tags.
- */
-export declare function structureTools(ctx: PluginContext): Record<string, ToolDefinition>;
-//# sourceMappingURL=structure.d.ts.map

package/dist/tools/structure.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"structure.d.ts","sourceRoot":"","sources":["../../src/tools/structure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAWjD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAyJjF"}