@rubytech/create-maxy 1.0.678 → 1.0.680

package/payload/platform/lib/graph-mcp/src/index.ts

@@ -28,6 +28,8 @@ import { accessSync, appendFileSync, constants, mkdirSync, readFileSync, statSyn
 import { resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { initStderrTee } from "../../mcp-stderr-tee/dist/index.js";
+import { validate as validateCypher, type UnknownToken } from "./cypher-validate.js";
+import { SchemaCache, neo4jSchemaFetcher } from "./schema-cache.js";
 
 const SERVER_NAME = "graph";
 const UPSTREAM_PACKAGE = "mcp-neo4j-cypher@0.6.0";
@@ -179,6 +181,38 @@ console.error(
     `namespace=${namespace} readOnly=${readOnly} tokenLimit=${responseTokenLimit}`,
 );
 
+// Task 654 — async schema cache. The validator fails OPEN until the first
+// refresh resolves; all cypher calls during that window are forwarded
+// unvalidated and the existing [graph-query] line gains `validated=false`
+// so operators see the bypass. One Neo4j driver is shared across refreshes;
+// loaded lazily so test harnesses can exercise SchemaCache without pulling
+// neo4j-driver into the module graph.
+// neo4jUri is narrowed to `string` by the guard throw above, but the narrow
+// doesn't flow into the closure below. Pin it to a local const whose type
+// is `string` by construction.
+const resolvedNeo4jUri: string = neo4jUri;
+let schemaFetcherReady: Promise<Awaited<ReturnType<typeof neo4jSchemaFetcher>>> | null = null;
+function getSchemaFetcher(): Promise<Awaited<ReturnType<typeof neo4jSchemaFetcher>>> {
+  if (!schemaFetcherReady) {
+    schemaFetcherReady = neo4jSchemaFetcher(resolvedNeo4jUri, neo4jUser, neo4jPassword);
+  }
+  return schemaFetcherReady;
+}
+const schemaCache = new SchemaCache({
+  async labels() {
+    const f = await getSchemaFetcher();
+    return f.labels();
+  },
+  async relationshipTypes() {
+    const f = await getSchemaFetcher();
+    return f.relationshipTypes();
+  },
+});
+void schemaCache.start().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(`[schema-cache] start failed error="${msg.replace(/"/g, "'")}"`);
+});
+
 const uvx = resolveUvxPath();
 if (!uvx.path) {
   syncEmit(
@@ -216,12 +250,18 @@ child.stderr.on("data", (chunk: Buffer) => {
   process.stderr.write(chunk);
 });
 
-// --- JSON-RPC call correlation ---
-// tools/call is the only method we time; initialize and tools/list are noise.
+// --- JSON-RPC call correlation + validation (Task 654) ---
+// tools/call is the only method we time or validate. For read/write cypher
+// calls, the line is validated against the schema cache before forwarding.
+// Write-path rejection: synthesised MCP tool-error response on stdout, NOT
+// forwarded. Read-path rejection: forwarded, with warnings appendix prepended
+// to response.content[0].text.
 interface PendingCall {
   method: string;
   cypherPrefix: string | null;
   startMs: number;
+  validated: boolean;
+  readWarnings: UnknownToken[];
 }
 const pending = new Map<string | number, PendingCall>();
 
@@ -235,18 +275,29 @@ function stripNamespace(toolName: string | undefined): string {
   return toolName.startsWith(prefix) ? toolName.slice(prefix.length) : toolName;
 }
 
+const READ_CYPHER_TOOL = "read_neo4j_cypher";
+const WRITE_CYPHER_TOOL = "write_neo4j_cypher";
+
 type JsonRpcMessage = {
+  jsonrpc?: string;
   id?: string | number;
   method?: string;
   params?: { name?: string; arguments?: Record<string, unknown> };
-  result?: { content?: Array<{ text?: string; type?: string }> };
+  result?: {
+    content?: Array<{ text?: string; type?: string }>;
+    isError?: boolean;
+  };
   error?: { message?: string; code?: number };
 };
 
-function extractCypher(args: Record<string, unknown> | undefined): string | null {
+function extractCypherFull(args: Record<string, unknown> | undefined): string | null {
   if (!args) return null;
   const q = args["query"] ?? args["cypher"];
-  return typeof q === "string" ? truncate(q.replace(/\s+/g, " ").trim(), 80) : null;
+  return typeof q === "string" ? q : null;
+}
+
+function truncateForLog(cypher: string): string {
+  return truncate(cypher.replace(/\s+/g, " ").trim(), 80);
 }
 
 function countRows(result: JsonRpcMessage["result"]): string {
@@ -257,72 +308,221 @@ function countRows(result: JsonRpcMessage["result"]): string {
   return String(result.content.length);
 }
 
-function onRequestLine(line: string): void {
+/**
+ * Render the admin-facing rejection or warnings text. Plain prose so the
+ * agent's Tool Failure Discipline reads it the same way it reads any tool
+ * error — no special-case structured JSON parser required.
+ */
+function renderUnknownTokens(
+  unknown: UnknownToken[],
+  mode: "rejected" | "warning",
+): string {
+  const heading = mode === "rejected"
+    ? "schema-validation rejected — cypher NOT executed"
+    : "schema-validation warning — cypher executed but referenced unknown tokens";
+  const lines = unknown.map((u) => {
+    const nearest = u.nearest.length > 0 ? ` nearest=[${u.nearest.join(", ")}]` : "";
+    return `  - ${u.kind} '${u.token}':${nearest} — ${u.hint}`;
+  });
+  return `${heading}\n${lines.join("\n")}`;
+}
+
+function synthesiseRejection(id: string | number, unknown: UnknownToken[]): string {
+  const text = `${renderUnknownTokens(unknown, "rejected")}\n\nFix the token names, or if the schema has just changed, invoke ${namespace}_get_neo4j_schema to refresh your view.`;
+  const envelope = {
+    jsonrpc: "2.0",
+    id,
+    result: {
+      content: [{ type: "text", text }],
+      isError: true,
+    },
+  };
+  return JSON.stringify(envelope);
+}
+
+function wrapReadWarnings(msg: JsonRpcMessage, warnings: UnknownToken[]): string {
+  const warningText = `${renderUnknownTokens(warnings, "warning")}\n\n--- results below (executed despite unknown tokens) ---\n`;
+  const original = msg.result?.content ?? [];
+  const wrapped: JsonRpcMessage = {
+    ...msg,
+    result: {
+      ...(msg.result ?? {}),
+      content: [{ type: "text", text: warningText }, ...original],
+    },
+  };
+  return JSON.stringify(wrapped);
+}
+
+type RequestDecision = "forward" | "intercepted";
+
+function handleRequestLine(line: string): RequestDecision {
+  let msg: JsonRpcMessage;
   try {
-    const msg = JSON.parse(line) as JsonRpcMessage;
-    if (msg.method === "tools/call" && msg.id !== undefined) {
-      pending.set(msg.id, {
-        method: stripNamespace(msg.params?.name),
-        cypherPrefix: extractCypher(msg.params?.arguments),
-        startMs: Date.now(),
-      });
-    }
+    msg = JSON.parse(line) as JsonRpcMessage;
   } catch {
-    // Non-JSON / partial line — forward untouched, don't log.
+    return "forward";
+  }
+  if (msg.method !== "tools/call" || msg.id === undefined) return "forward";
+
+  const methodName = stripNamespace(msg.params?.name);
+  const cypherFull = extractCypherFull(msg.params?.arguments);
+  const cypherPrefix = cypherFull ? truncateForLog(cypherFull) : null;
+  const isCypherCall =
+    methodName === READ_CYPHER_TOOL || methodName === WRITE_CYPHER_TOOL;
+
+  const entry: PendingCall = {
+    method: methodName,
+    cypherPrefix,
+    startMs: Date.now(),
+    validated: false,
+    readWarnings: [],
+  };
+
+  if (!isCypherCall || !cypherFull) {
+    pending.set(msg.id, entry);
+    return "forward";
   }
+
+  const isWrite = methodName === WRITE_CYPHER_TOOL;
+  const snapshot = schemaCache.snapshot();
+  const cacheReady = schemaCache.ready();
+
+  if (!cacheReady) {
+    console.error(
+      `[cypher-validate] tool=${isWrite ? "write" : "read"} outcome=skipped reason=cache-not-ready cypher="${(cypherPrefix ?? "").replace(/"/g, "'")}"`,
+    );
+    pending.set(msg.id, entry);
+    return "forward";
+  }
+
+  const result = validateCypher(cypherFull, snapshot);
+  entry.validated = true;
+
+  if (result.ok) {
+    console.error(
+      `[cypher-validate] tool=${isWrite ? "write" : "read"} outcome=accepted labels=${result.labelTokens.length} relationships=${result.edgeTokens.length}`,
+    );
+    pending.set(msg.id, entry);
+    return "forward";
+  }
+
+  void schemaCache.maybeRebuildOnStaleMiss(result.unknown);
+  const tokenSummary = result.unknown
+    .map((u) => `${u.kind}:${u.token}`)
+    .join(",");
+
+  if (isWrite) {
+    console.error(
+      `[cypher-validate] tool=write outcome=rejected unknown=${tokenSummary} cypher="${(cypherPrefix ?? "").replace(/"/g, "'")}"`,
+    );
+    const response = synthesiseRejection(msg.id, result.unknown);
+    process.stdout.write(`${response}\n`);
+    console.error(
+      `[graph-query] op=${methodName} brand=${brand} port=${neo4jPort} cypher="${(cypherPrefix ?? "").replace(/"/g, "'")}" rejected=true validated=true ms=${Date.now() - entry.startMs}`,
+    );
+    return "intercepted";
+  }
+
+  entry.readWarnings = result.unknown;
+  console.error(
+    `[cypher-validate] tool=read outcome=warned unknown=${tokenSummary} cypher="${(cypherPrefix ?? "").replace(/"/g, "'")}"`,
+  );
+  pending.set(msg.id, entry);
+  return "forward";
 }
 
-function onResponseLine(line: string): void {
+function handleResponseLine(line: string): string | null {
+  let msg: JsonRpcMessage;
   try {
-    const msg = JSON.parse(line) as JsonRpcMessage;
-    if (msg.id === undefined || !pending.has(msg.id)) return;
-    const p = pending.get(msg.id)!;
-    pending.delete(msg.id);
-    const elapsed = Date.now() - p.startMs;
-    const cypherField = p.cypherPrefix ? `cypher="${p.cypherPrefix.replace(/"/g, "'")}"` : "";
-    if (msg.error) {
-      const errText = (msg.error.message ?? JSON.stringify(msg.error)).replace(/"/g, "'");
-      console.error(
-        `[graph-query] op=${p.method} brand=${brand} port=${neo4jPort} ${cypherField} error="${errText}" ms=${elapsed}`,
-      );
-    } else {
-      const rows = countRows(msg.result);
+    msg = JSON.parse(line) as JsonRpcMessage;
+  } catch {
+    return null;
+  }
+  if (msg.id === undefined || !pending.has(msg.id)) return null;
+  const p = pending.get(msg.id)!;
+  pending.delete(msg.id);
+  const elapsed = Date.now() - p.startMs;
+  const cypherField = p.cypherPrefix ? `cypher="${p.cypherPrefix.replace(/"/g, "'")}"` : "";
+  const validatedField = `validated=${p.validated}`;
+  if (msg.error) {
+    const errText = (msg.error.message ?? JSON.stringify(msg.error)).replace(/"/g, "'");
+    console.error(
+      `[graph-query] op=${p.method} brand=${brand} port=${neo4jPort} ${cypherField} error="${errText}" ${validatedField} ms=${elapsed}`,
+    );
+    return null;
+  }
+  const rows = countRows(msg.result);
+  const warnedField = p.readWarnings.length > 0 ? ` warned=${p.readWarnings.length}` : "";
+  console.error(
+    `[graph-query] op=${p.method} brand=${brand} port=${neo4jPort} ${cypherField} rows=${rows} ${validatedField}${warnedField} ms=${elapsed}`,
+  );
+  if (p.readWarnings.length > 0) {
+    try {
+      return wrapReadWarnings(msg, p.readWarnings);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       console.error(
-        `[graph-query] op=${p.method} brand=${brand} port=${neo4jPort} ${cypherField} rows=${rows} ms=${elapsed}`,
+        `[cypher-validate] warning-wrap failed op=${p.method} error="${errMsg.replace(/"/g, "'")}" — forwarding response unwrapped`,
       );
+      return null;
     }
-  } catch {
-    // Non-JSON — forward untouched.
   }
+  return null;
 }
 
-function makeLineSplitter(onLine: (line: string) => void): (chunk: Buffer) => void {
+/**
+ * Per-stream buffering splitter. Yields complete lines (without trailing \n)
+ * as they accumulate; leaves any partial tail in the buffer until more bytes
+ * arrive. Unlike the pre-Task-652 splitter, this one lets the caller decide
+ * per-line whether to forward or intercept — the original splitter was
+ * fire-and-forget and the raw chunk was forwarded unconditionally alongside,
+ * which ruled out interception.
+ */
+function makeLineBuffer(): { push: (chunk: Buffer) => string[] } {
   const decoder = new StringDecoder("utf8");
   let buf = "";
-  return (chunk: Buffer) => {
-    buf += decoder.write(chunk);
-    let idx: number;
-    while ((idx = buf.indexOf("\n")) !== -1) {
-      const line = buf.slice(0, idx);
-      buf = buf.slice(idx + 1);
-      if (line.length > 0) onLine(line);
-    }
+  return {
+    push(chunk: Buffer): string[] {
+      buf += decoder.write(chunk);
+      const out: string[] = [];
+      let idx: number;
+      while ((idx = buf.indexOf("\n")) !== -1) {
+        out.push(buf.slice(0, idx));
+        buf = buf.slice(idx + 1);
+      }
+      return out;
+    },
   };
 }
 
-const splitRequest = makeLineSplitter(onRequestLine);
+const requestBuffer = makeLineBuffer();
 process.stdin.on("data", (chunk: Buffer) => {
-  splitRequest(chunk);
-  child.stdin.write(chunk);
+  for (const line of requestBuffer.push(chunk)) {
+    if (line.length === 0) {
+      child.stdin.write("\n");
+      continue;
+    }
+    const decision = handleRequestLine(line);
+    if (decision === "forward") {
+      child.stdin.write(`${line}\n`);
+    }
+    // "intercepted" — synthesised response already written to stdout.
+  }
 });
 process.stdin.on("end", () => {
   child.stdin.end();
 });
 
-const splitResponse = makeLineSplitter(onResponseLine);
+const responseBuffer = makeLineBuffer();
 child.stdout.on("data", (chunk: Buffer) => {
-  splitResponse(chunk);
-  process.stdout.write(chunk);
+  for (const line of responseBuffer.push(chunk)) {
+    if (line.length === 0) {
+      process.stdout.write("\n");
+      continue;
+    }
+    const rewritten = handleResponseLine(line);
+    process.stdout.write(`${rewritten ?? line}\n`);
+  }
 });
 child.stdout.on("end", () => {
   process.stdout.end();

package/payload/platform/lib/graph-mcp/src/schema-cache.ts

@@ -0,0 +1,212 @@
+/**
+ * Per-process schema cache for the graph-mcp proxy (Task 654).
+ *
+ * Caches { labels, relationshipTypes } from the connected Neo4j instance so
+ * the cypher validator can look up tokens without a round-trip per call.
+ *
+ * Refresh triggers:
+ *   - boot           — async refresh kicked off by start(); validator fails
+ *                      OPEN until the first refresh resolves.
+ *   - interval       — every 60s (configurable) while the process is alive.
+ *   - stale-miss     — an unknown token with a near match (edit distance ≤ 2)
+ *                      triggers a debounced refresh, catching fresh migrations
+ *                      without requiring operators to wait out the interval.
+ *
+ * Failure posture:
+ *   - A refresh that throws preserves the last good snapshot and leaves
+ *     ready() as it was. `[schema-cache] refresh failure ...` is logged
+ *     loudly so operators see persistent Neo4j unreachability.
+ *   - A boot refresh that fails leaves ready()=false and the snapshot empty.
+ *     The validator's own fail-open branch handles this (empty snapshot →
+ *     ok=true, no rejections), so the graph-mcp proxy keeps working against
+ *     a still-reachable Neo4j instance that's just slow to respond to the
+ *     initial `db.labels()` call.
+ */
+
+import type { SchemaSnapshot, UnknownToken } from "./cypher-validate.js";
+
+export interface SchemaFetcher {
+  labels(): Promise<string[]>;
+  relationshipTypes(): Promise<string[]>;
+}
+
+export interface SchemaCacheOptions {
+  /** Interval between automatic refreshes. 0 disables the timer (tests). */
+  refreshIntervalMs?: number;
+  /** Minimum ms between stale-miss-triggered refreshes. Default 5000. */
+  staleMissDebounceMs?: number;
+  /** Emit a log line. Default: stderr. Tests inject to capture. */
+  emit?: (line: string) => void;
+}
+
+const DEFAULT_REFRESH_INTERVAL_MS = 60_000;
+const DEFAULT_STALE_MISS_DEBOUNCE_MS = 5_000;
+const STALE_MISS_DISTANCE_CEILING = 2;
+
+export class SchemaCache {
+  private _labels = new Set<string>();
+  private _rels = new Set<string>();
+  private _ready = false;
+  private _timer: ReturnType<typeof setInterval> | null = null;
+  private _refreshInFlight: Promise<boolean> | null = null;
+  private _lastStaleMissAt = 0;
+
+  constructor(
+    private readonly fetcher: SchemaFetcher,
+    private readonly options: SchemaCacheOptions = {},
+  ) {}
+
+  snapshot(): SchemaSnapshot {
+    return { labels: this._labels, relationshipTypes: this._rels };
+  }
+
+  ready(): boolean {
+    return this._ready;
+  }
+
+  async start(): Promise<void> {
+    await this.refresh("boot");
+    const interval = this.options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS;
+    if (interval > 0) {
+      this._timer = setInterval(() => {
+        void this.refresh("interval");
+      }, interval);
+      // Allow the process to exit without waiting for the timer.
+      if (typeof this._timer === "object" && "unref" in this._timer) {
+        (this._timer as { unref?: () => void }).unref?.();
+      }
+    }
+  }
+
+  stop(): void {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  /**
+   * Refresh the cache. Single-flight: concurrent calls await the same in-flight
+   * promise rather than triggering overlapping Neo4j reads. Returns true on
+   * successful update, false on failure (last good snapshot preserved).
+   */
+  async refresh(reason: string): Promise<boolean> {
+    if (this._refreshInFlight) return this._refreshInFlight;
+    const run = async (): Promise<boolean> => {
+      const started = Date.now();
+      try {
+        const [labels, rels] = await Promise.all([
+          this.fetcher.labels(),
+          this.fetcher.relationshipTypes(),
+        ]);
+        this._labels = new Set(labels);
+        this._rels = new Set(rels);
+        this._ready = true;
+        this.emit(
+          `[schema-cache] refresh reason=${reason} labels=${this._labels.size} relationshipTypes=${this._rels.size} ms=${Date.now() - started}`,
+        );
+        return true;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.emit(
+          `[schema-cache] refresh failure reason=${reason} ms=${Date.now() - started} error="${msg.replace(/"/g, "'")}"`,
+        );
+        return false;
+      }
+    };
+    this._refreshInFlight = run();
+    try {
+      return await this._refreshInFlight;
+    } finally {
+      this._refreshInFlight = null;
+    }
+  }
+
+  /**
+   * If the validator returned unknown tokens whose nearest known token is
+   * within STALE_MISS_DISTANCE_CEILING edits, trigger an out-of-band refresh
+   * (debounced). The heuristic: a near-miss is likely a fresh migration
+   * (renamed / newly added label/edge), where a far-miss is almost certainly
+   * a typo and a refresh would not change the outcome. Returns true iff a
+   * refresh was actually run this call.
+   */
+  async maybeRebuildOnStaleMiss(unknown: UnknownToken[]): Promise<boolean> {
+    if (unknown.length === 0) return false;
+    const now = Date.now();
+    const debounceMs =
+      this.options.staleMissDebounceMs ?? DEFAULT_STALE_MISS_DEBOUNCE_MS;
+    if (now - this._lastStaleMissAt < debounceMs) return false;
+    const anyNearMiss = unknown.some((u) => {
+      if (u.nearest.length === 0) return false;
+      return editDistance(u.token, u.nearest[0]) <= STALE_MISS_DISTANCE_CEILING;
+    });
+    if (!anyNearMiss) return false;
+    this._lastStaleMissAt = now;
+    await this.refresh("stale-miss");
+    return true;
+  }
+
+  private emit(line: string): void {
+    if (this.options.emit) {
+      this.options.emit(line);
+    } else {
+      process.stderr.write(`${line}\n`);
+    }
+  }
+}
+
+/**
+ * Build a SchemaFetcher over a long-lived neo4j-driver Driver. Each call
+ * opens a fresh session (cheap, sub-ms) and closes it in finally so the
+ * driver's connection pool stays small. Consumer owns the driver lifecycle.
+ *
+ * Import is deferred to the factory call so that test files can exercise
+ * the SchemaCache class without pulling neo4j-driver into the module graph.
+ */
+export async function neo4jSchemaFetcher(
+  uri: string,
+  user: string,
+  password: string,
+): Promise<SchemaFetcher> {
+  const neo4j = await import("neo4j-driver");
+  const driver = neo4j.default.driver(uri, neo4j.default.auth.basic(user, password));
+  const query = async (cypher: string): Promise<string[]> => {
+    const session = driver.session();
+    try {
+      const result = await session.run(cypher);
+      return result.records
+        .map((r) => r.get(0))
+        .filter((v): v is string => typeof v === "string");
+    } finally {
+      await session.close();
+    }
+  };
+  return {
+    async labels() {
+      return query("CALL db.labels() YIELD label RETURN label");
+    },
+    async relationshipTypes() {
+      return query(
+        "CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType",
+      );
+    },
+  };
+}
+
+function editDistance(a: string, b: string): number {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = new Array<number>(b.length + 1);
+  let curr = new Array<number>(b.length + 1);
+  for (let j = 0; j <= b.length; j++) prev[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length];
+}

package/payload/platform/lib/graph-trash/dist/index.d.ts

@@ -13,6 +13,14 @@
  * are snapshotted into `_trashedKeys` (JSON) and nulled on the node, so
  * MERGE against the same key won't collide. `restoreNode` writes them back
  * and fails loudly when an active node already occupies the slot.
+ *
+ * Label-aware cascade (Task 655): when `trashNode` trashes a `:Conversation`,
+ * it also trashes every `(m:Message)-[:PART_OF]->(c)` Message in the same
+ * managed transaction. This makes `MATCH (m:Trashed)` a correct audit
+ * primitive again — pre-Task-655 a Conversation trash left attached Messages
+ * un-labelled, so audits that filtered `m:Trashed` silently under-reported
+ * the blast radius of the 2026-04-22 incident by a factor of 10+.
+ * `restoreNode` reverses both sides.
  */
 import type { Session } from "neo4j-driver";
 export interface TrashParams {

package/payload/platform/lib/graph-trash/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuC5C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,wBAAsB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAyEzE;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAkE/E;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uFAAuF;IACvF,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,qFAAqF;IACrF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0EpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAI9D;AAED,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuC5C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,wBAAsB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAyIzE;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CA6G/E;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uFAAuF;IACvF,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,qFAAqF;IACrF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0EpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAI9D;AAED,2FAA2F;AAC3F,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAqB,CAAC"}