@pylonsync/sync 0.3.127 → 0.3.130

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.127",
+  "version": "0.3.130",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -106,6 +106,39 @@ export class LocalStore {
     return this.tables.get(entity)?.get(id) ?? null;
   }
 
+  /** Snapshot of every entity name with at least one local row. Used by
+   *  `SyncEngine.reconcile` to know which tables to diff against the
+   *  server's current truth. Returning a fresh array lets callers iterate
+   *  without holding a reference into the live map. */
+  entityNames(): string[] {
+    const names: string[] = [];
+    for (const [name, table] of this.tables) {
+      if (table.size > 0) names.push(name);
+    }
+    return names;
+  }
+
+  /**
+   * Remove a row recorded as deleted by the server-truth reconciler.
+   * Records a tombstone at `tombstoneSeq` so a stale insert/update
+   * replayed afterwards (e.g. from a slow WS frame) doesn't resurrect
+   * it. Callers pass the current sync cursor as `tombstoneSeq` — any
+   * future change events will have higher seqs and pass the tombstone
+   * check; older replays will be filtered.
+   *
+   * Differs from `optimisticDelete` which uses `MAX_SAFE_INTEGER` (the
+   * caller is asserting it knows the future). Reconciliation only knows
+   * what the server currently shows; a row re-created server-side later
+   * MUST be allowed back in.
+   */
+  reconcileRemove(entity: string, id: string, tombstoneSeq: number): boolean {
+    const table = this.tables.get(entity);
+    if (!table || !table.has(id)) return false;
+    table.delete(id);
+    this.recordTombstone(entity, id, tombstoneSeq);
+    return true;
+  }
+
   /** Check if `(entity, id)` has a tombstone. */
   private isTombstoned(entity: string, id: string, at_seq?: number): boolean {
     const tombSeq = this.tombstones.get(entity)?.get(id);
@@ -494,6 +527,20 @@ export interface SyncEngineConfig {
    * hosts (RN, Tauri, Workers) inject an adapter to persist these values.
    */
   storage?: import("./storage").Storage;
+  /**
+   * Debounce window (ms) between `reconcile()` calls. Reconcile triggers
+   * fire on connect, WS reconnect, and visibility-change; the debounce
+   * prevents the back-to-back triggers from re-fetching every entity
+   * twice within seconds. Default 2000ms.
+   */
+  reconcileMinIntervalMs?: number;
+  /**
+   * Opt out of the automatic visibility-change reconcile. The reconcile
+   * pass runs on connect/reconnect regardless; this only disables the
+   * tab-refocus trigger. Default: enabled (reconcile fires when the tab
+   * becomes visible).
+   */
+  reconcileOnVisibility?: boolean;
 }
 
 /**
@@ -834,6 +881,21 @@ export class SyncEngine {
       await this.persistence.saveCursor(this.cursor);
     }
 
+    // First-load reconciliation pass — closes the "phantom row" gap when
+    // the local IndexedDB has rows the server doesn't (deletes made by
+    // another surface while this tab was closed, or events that fell
+    // off the in-memory ChangeLog before this tab's cursor caught up).
+    // Fires after pull so we don't reconcile against rows that pull
+    // would have applied anyway. Errors are swallowed inside
+    // reconcileInner so a failed reconcile doesn't take down startup.
+    void this.reconcile();
+
+    // Wire the visibility-change reconcile so a tab that returns from
+    // the background (laptop wakes, tab unhidden) catches up against
+    // server truth without waiting for a WS event. Closes the "Stripe
+    // webhook on a sibling Fly machine" / "missed WS event" gap.
+    this.attachVisibilityListener();
+
     const transport = this.config.transport ?? "websocket";
     if (transport === "websocket") {
       this.connectWs();
@@ -844,6 +906,24 @@ export class SyncEngine {
     }
   }
 
+  private visibilityHandler: (() => void) | null = null;
+  private attachVisibilityListener(): void {
+    if (this.config.reconcileOnVisibility === false) return;
+    if (typeof document === "undefined") return;
+    if (this.visibilityHandler) return;
+    this.visibilityHandler = () => {
+      if (document.visibilityState !== "visible") return;
+      if (!this.running) return;
+      // Reconcile fires only on tab-becomes-visible; the debounce in
+      // reconcile() collapses bursts from rapid background/foreground
+      // flips. Pull runs alongside so cursor catches up to anything
+      // emitted while the tab was hidden.
+      void this.pull();
+      void this.reconcile();
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+
   private pollTimer: ReturnType<typeof setInterval> | null = null;
 
   private startPolling(): void {
@@ -868,6 +948,10 @@ export class SyncEngine {
       clearInterval(this.pollTimer);
       this.pollTimer = null;
     }
+    if (this.visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
     this.setConnectionStatus("offline");
   }
 
@@ -919,6 +1003,14 @@ export class SyncEngine {
         const [entity, rowId] = key.split("\x00");
         this.sendWs({ type: "crdt-subscribe", entity, rowId });
       }
+      // Pull-on-open catches every event broadcast in the gap between
+      // the prior `pull()` returning and this socket actually opening.
+      // The WS has no replay-on-connect (it's just a fanout), so events
+      // emitted to other live clients during that window would otherwise
+      // be lost forever to this tab. Reconcile fires after the pull
+      // since pull is the cheap incremental path; reconcile is the
+      // server-truth backstop for anything pull couldn't replay.
+      void this.pull().then(() => this.reconcile());
     };
 
     // Bind binaryType BEFORE installing the handler so the first
@@ -1114,12 +1206,19 @@ export class SyncEngine {
    * Does NOT issue the subsequent pull — callers decide when to re-pull.
    * That keeps the lifecycle explicit: a caller can reset, swap config,
    * then pull.
+   *
+   * Clears IndexedDB too. Without that, locals that should have been
+   * deleted server-side (e.g. another client deleted rows while this tab
+   * was closed, then this tab's cursor 410'd) survived on disk and got
+   * rehydrated on the next page load — phantom rows that no purge of
+   * in-memory state could fix.
    */
   async resetReplica(): Promise<void> {
     this.cursor = { last_seq: 0 };
     this.store.clearAll();
     if (this.persistence) {
       try {
+        await this.persistence.clear();
         await this.persistence.saveCursor(this.cursor);
       } catch {
         /* best-effort */
@@ -1239,6 +1338,200 @@ export class SyncEngine {
    *  that doesn't throw a 410. */
   private consecutive_410s = 0;
 
+  /** Timestamp of the last `reconcile()` invocation. Used to debounce —
+   *  reconcile runs on connect, WS reconnect, AND visibility-change, so
+   *  a quick tab-flick after a normal reconnect shouldn't refetch every
+   *  entity twice within seconds. Configurable via `reconcileMinIntervalMs`. */
+  private lastReconcileAt = 0;
+
+  /** In-flight reconcile promise — coalesces concurrent callers so a
+   *  visibility-change firing during an in-progress reconcile doesn't
+   *  double the work. */
+  private inFlightReconcile: Promise<void> | null = null;
+
+  /**
+   * Reconcile the local replica against server truth.
+   *
+   * For each entity that has at least one local row, fetch the
+   * authoritative row set from `/api/entities/<entity>` (already
+   * policy-filtered) and apply the diff:
+   *
+   * - Local rows whose id is missing from the server set → removed.
+   * - Server rows whose JSON differs from local → overwritten.
+   * - Server rows the local replica doesn't have → inserted.
+   *
+   * This is the safety net the WS / pull path can't provide on its own:
+   *
+   *   - Deletes made by other surfaces (Mac SDK, server-side actions,
+   *     admin tools) while this client was offline can fall off the
+   *     in-memory ChangeLog before this client reconnects. The pull
+   *     then returns an empty diff and the local phantom rows persist
+   *     forever. Reconcile catches them.
+   *
+   *   - Mutations broadcast on a sibling Fly machine (multi-instance
+   *     deploys, autoscaled apps) never reach this WS. Reconcile is
+   *     the only mechanism that observes them.
+   *
+   *   - Events broadcast in the brief window between a pull completing
+   *     and the WS opening get dropped because the WS has no replay-
+   *     on-connect; reconcile makes those eventually-consistent.
+   *
+   * Debounced via `lastReconcileAt` so a flurry of triggers
+   * (reconnect + visibility-change firing back-to-back) coalesces to
+   * one network round per entity.
+   *
+   * Pass an explicit entity list to scope the reconcile (callers like
+   * `db.useQueryOne` that know what they care about). When called with
+   * no arg, every entity with local rows is checked.
+   */
+  async reconcile(entities?: string[]): Promise<void> {
+    if (this.inFlightReconcile) return this.inFlightReconcile;
+    const minIntervalMs = this.config.reconcileMinIntervalMs ?? 2_000;
+    const now = Date.now();
+    if (entities === undefined && now - this.lastReconcileAt < minIntervalMs) {
+      return;
+    }
+    const work = this.reconcileInner(entities).finally(() => {
+      this.inFlightReconcile = null;
+      this.lastReconcileAt = Date.now();
+    });
+    this.inFlightReconcile = work;
+    return work;
+  }
+
+  private async reconcileInner(entities?: string[]): Promise<void> {
+    const names = entities ?? this.store.entityNames();
+    if (names.length === 0) return;
+    // Tombstone seq for any local row the server doesn't return. Using
+    // the current cursor means future inserts (which have higher seqs)
+    // bypass the tombstone — re-creation server-side still propagates.
+    const tombstoneSeq = this.cursor.last_seq;
+    for (const entity of names) {
+      let serverRows: Row[];
+      try {
+        serverRows = await this.fetchEntityRows(entity);
+      } catch (err) {
+        // Network errors are expected (offline, transient 5xx). Skip
+        // this entity; the next reconcile trigger will retry.
+        const status = (err as { status?: number })?.status;
+        if (status === 403 || status === 404) {
+          // Entity is no longer readable (policy revoked) or removed
+          // from the manifest. Drop every local row for it — keeping
+          // them around just leaks invisible state.
+          await this.dropEntity(entity, tombstoneSeq);
+        }
+        continue;
+      }
+      await this.applyEntityReconcile(entity, serverRows, tombstoneSeq);
+    }
+  }
+
+  /** Fetch every row for an entity. Uses cursor pagination so big tables
+   *  don't blow past server-side limits; loops until `has_more` is false
+   *  or a safety cap is hit. */
+  private async fetchEntityRows(entity: string): Promise<Row[]> {
+    const out: Row[] = [];
+    let cursor: string | null = null;
+    // 200 pages × 100 per page = 20k rows. Anything larger should not be
+    // mirrored client-side anyway — see useInfiniteQuery for huge tables.
+    for (let page = 0; page < 200; page++) {
+      const qs: string = cursor
+        ? `?limit=100&after=${encodeURIComponent(cursor)}`
+        : `?limit=100`;
+      const resp: {
+        data: Row[];
+        next_cursor: string | null;
+        has_more: boolean;
+      } = await this.request("GET", `/api/entities/${entity}/cursor${qs}`);
+      for (const row of resp.data) out.push(row);
+      if (!resp.has_more || !resp.next_cursor) break;
+      cursor = resp.next_cursor;
+    }
+    return out;
+  }
+
+  private async applyEntityReconcile(
+    entity: string,
+    serverRows: Row[],
+    tombstoneSeq: number,
+  ): Promise<void> {
+    const serverIds = new Set<string>();
+    const changes: ChangeEvent[] = [];
+    for (const row of serverRows) {
+      const id = (row as { id?: unknown }).id;
+      if (typeof id !== "string" || id.length === 0) continue;
+      serverIds.add(id);
+      const local = this.store.get(entity, id);
+      if (!local) {
+        changes.push({
+          seq: tombstoneSeq + 1,
+          entity,
+          row_id: id,
+          kind: "insert",
+          data: row,
+          timestamp: "",
+        });
+      } else if (rowsDiffer(local, row)) {
+        changes.push({
+          seq: tombstoneSeq + 1,
+          entity,
+          row_id: id,
+          kind: "update",
+          data: row,
+          timestamp: "",
+        });
+      }
+    }
+    if (changes.length > 0) {
+      await this.store.applyChangesAsync(changes);
+    }
+    // Removals: every local row whose id isn't in the server set is
+    // stale. Tombstone with the current cursor so future legitimate
+    // re-creations still flow through.
+    const locals = this.store.list(entity);
+    let removed = false;
+    for (const local of locals) {
+      const id = (local as { id?: unknown }).id;
+      if (typeof id !== "string") continue;
+      if (!serverIds.has(id)) {
+        if (this.store.reconcileRemove(entity, id, tombstoneSeq)) {
+          removed = true;
+          if (this.persistence) {
+            try {
+              await this.persistence.deleteRow(entity, id);
+            } catch {
+              /* best-effort */
+            }
+          }
+        }
+      }
+    }
+    if (removed) this.store.notify();
+  }
+
+  private async dropEntity(
+    entity: string,
+    tombstoneSeq: number,
+  ): Promise<void> {
+    const locals = this.store.list(entity);
+    let removed = false;
+    for (const local of locals) {
+      const id = (local as { id?: unknown }).id;
+      if (typeof id !== "string") continue;
+      if (this.store.reconcileRemove(entity, id, tombstoneSeq)) {
+        removed = true;
+        if (this.persistence) {
+          try {
+            await this.persistence.deleteRow(entity, id);
+          } catch {
+            /* best-effort */
+          }
+        }
+      }
+    }
+    if (removed) this.store.notify();
+  }
+
   /**
    * Fetch `/api/auth/me` and update the cached `_resolvedSession`. Callers:
    *   - `start()` — initial load
@@ -1670,6 +1963,30 @@ export async function getServerData(
   return { entities: entityData, cursor };
 }
 
+/**
+ * Stable equality check for reconciler diffs. Keys are sorted so
+ * `{a:1,b:2}` and `{b:2,a:1}` compare equal — without that, every
+ * reconcile pass would think every row had changed (insertion order
+ * varies by mutation path on the server). Recursive on objects only;
+ * arrays and primitives use their natural shape.
+ */
+function rowsDiffer(a: Row, b: Row): boolean {
+  return stableStringify(a) !== stableStringify(b);
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => stableStringify(v)).join(",") + "]";
+  }
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  const parts = keys.map(
+    (k) => JSON.stringify(k) + ":" + stableStringify(obj[k]),
+  );
+  return "{" + parts.join(",") + "}";
+}
+
 // ---------------------------------------------------------------------------
 // Convenience factory
 // ---------------------------------------------------------------------------

package/src/reconcile.test.ts

@@ -0,0 +1,296 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { SyncEngine, type ChangeEvent, type Row } from "./index";
+
+// ---------------------------------------------------------------------------
+// Minimal fetch stub + in-memory persistence shim so the tests exercise
+// the reconcile code path without a real browser environment.
+// ---------------------------------------------------------------------------
+
+type FetchHandler = (
+  url: string,
+  init?: RequestInit,
+) => Promise<{ status: number; body: unknown }>;
+
+function installFetch(handler: FetchHandler): () => void {
+  const original = globalThis.fetch;
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const { status, body } = await handler(url, init);
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      json: async () => body,
+      text: async () => JSON.stringify(body),
+    } as Response;
+  }) as typeof fetch;
+  return () => {
+    globalThis.fetch = original;
+  };
+}
+
+function makeEngine(): SyncEngine {
+  // `persist: false` short-circuits the IndexedDB import — these tests
+  // run on the Bun runtime which has no `indexedDB` global. Reconcile
+  // itself only touches `this.persistence` defensively, so disabling
+  // the layer is harmless here.
+  return new SyncEngine({
+    baseUrl: "http://stub.invalid",
+    persist: false,
+    reconcileMinIntervalMs: 0,
+  });
+}
+
+// Seed rows directly into the in-memory store (bypassing the WS / pull
+// path so the test isolates `reconcile`'s diff semantics).
+function seedStore(engine: SyncEngine, entity: string, rows: Row[]): void {
+  for (const row of rows) {
+    const id = (row as { id?: unknown }).id;
+    if (typeof id !== "string") continue;
+    const ev: ChangeEvent = {
+      seq: 0,
+      entity,
+      row_id: id,
+      kind: "insert",
+      data: row,
+      timestamp: "",
+    };
+    engine.store.applyChange(ev);
+  }
+}
+
+describe("SyncEngine.reconcile", () => {
+  let restore: (() => void) | null = null;
+
+  afterEach(() => {
+    restore?.();
+    restore = null;
+  });
+
+  test("removes local rows the server no longer returns (Repro A)", async () => {
+    // Server truth: only row "r1" survives.
+    restore = installFetch(async (url) => {
+      if (url.includes("/api/entities/Recording/cursor")) {
+        return {
+          status: 200,
+          body: {
+            data: [{ id: "r1", title: "alive" }],
+            next_cursor: null,
+            has_more: false,
+          },
+        };
+      }
+      return { status: 404, body: {} };
+    });
+
+    const engine = makeEngine();
+    seedStore(engine, "Recording", [
+      { id: "r1", title: "alive" },
+      { id: "r2", title: "phantom" },
+      { id: "r3", title: "phantom" },
+    ]);
+
+    expect(engine.store.list("Recording").length).toBe(3);
+
+    await engine.reconcile(["Recording"]);
+
+    const remaining = engine.store.list("Recording");
+    expect(remaining.length).toBe(1);
+    expect((remaining[0] as { id: string }).id).toBe("r1");
+  });
+
+  test("updates local rows whose content drifted from server (Repro B)", async () => {
+    restore = installFetch(async (url) => {
+      if (url.includes("/api/entities/Org/cursor")) {
+        return {
+          status: 200,
+          body: {
+            data: [
+              {
+                id: "org_1",
+                plan: "lifetime",
+                subscriptionStatus: "active",
+              },
+            ],
+            next_cursor: null,
+            has_more: false,
+          },
+        };
+      }
+      return { status: 404, body: {} };
+    });
+
+    const engine = makeEngine();
+    seedStore(engine, "Org", [
+      { id: "org_1", plan: "pending", subscriptionStatus: "incomplete" },
+    ]);
+
+    await engine.reconcile(["Org"]);
+
+    const row = engine.store.get("Org", "org_1") as {
+      plan: string;
+      subscriptionStatus: string;
+    } | null;
+    expect(row).not.toBeNull();
+    expect(row!.plan).toBe("lifetime");
+    expect(row!.subscriptionStatus).toBe("active");
+  });
+
+  test("inserts server rows the local replica is missing", async () => {
+    restore = installFetch(async (url) => {
+      if (url.includes("/api/entities/Recording/cursor")) {
+        return {
+          status: 200,
+          body: {
+            data: [
+              { id: "r1", title: "one" },
+              { id: "r2", title: "two" },
+            ],
+            next_cursor: null,
+            has_more: false,
+          },
+        };
+      }
+      return { status: 404, body: {} };
+    });
+
+    const engine = makeEngine();
+    seedStore(engine, "Recording", [{ id: "r1", title: "one" }]);
+
+    await engine.reconcile(["Recording"]);
+
+    expect(engine.store.list("Recording").length).toBe(2);
+    expect(engine.store.get("Recording", "r2")).not.toBeNull();
+  });
+
+  test("removed rows record a tombstone bound to the cursor, not MAX_SAFE_INTEGER", async () => {
+    // Server has nothing — every local row should be dropped.
+    restore = installFetch(async () => ({
+      status: 200,
+      body: { data: [], next_cursor: null, has_more: false },
+    }));
+
+    const engine = makeEngine();
+    seedStore(engine, "Recording", [{ id: "r_ghost", title: "phantom" }]);
+    await engine.reconcile(["Recording"]);
+    expect(engine.store.list("Recording").length).toBe(0);
+
+    // A server-broadcast insert that arrives AFTER reconcile must be
+    // accepted — the tombstone is bound to the current cursor (0 here),
+    // and the new event has seq > 0 so it bypasses the tombstone check.
+    // Without the cursor-bound tombstone (e.g. MAX_SAFE_INTEGER), the
+    // row could never come back even after legitimate server-side
+    // re-creation.
+    engine.store.applyChange({
+      seq: 1,
+      entity: "Recording",
+      row_id: "r_ghost",
+      kind: "insert",
+      data: { id: "r_ghost", title: "recreated" },
+      timestamp: "",
+    });
+    expect(engine.store.get("Recording", "r_ghost")).not.toBeNull();
+  });
+
+  test("no-op when no entities have local rows", async () => {
+    let calls = 0;
+    restore = installFetch(async () => {
+      calls += 1;
+      return { status: 200, body: { data: [], next_cursor: null, has_more: false } };
+    });
+
+    const engine = makeEngine();
+    await engine.reconcile(); // unscoped — should find no entities to check
+    expect(calls).toBe(0);
+  });
+
+  test("debounces back-to-back unscoped calls", async () => {
+    let calls = 0;
+    restore = installFetch(async () => {
+      calls += 1;
+      return {
+        status: 200,
+        body: {
+          data: [{ id: "r1", title: "alive" }],
+          next_cursor: null,
+          has_more: false,
+        },
+      };
+    });
+
+    // Engine with a 5s debounce — reconcile twice in a row should only
+    // hit the network once.
+    const engine = new SyncEngine({
+      baseUrl: "http://stub.invalid",
+      persist: false,
+      reconcileMinIntervalMs: 5_000,
+    });
+    seedStore(engine, "Recording", [{ id: "r1", title: "alive" }]);
+
+    await engine.reconcile();
+    await engine.reconcile();
+    expect(calls).toBe(1);
+  });
+
+  test("404 on entity → drops every local row for it", async () => {
+    restore = installFetch(async () => ({ status: 404, body: {} }));
+
+    const engine = makeEngine();
+    seedStore(engine, "DeletedEntity", [{ id: "x", value: 1 }]);
+    await engine.reconcile(["DeletedEntity"]);
+    expect(engine.store.list("DeletedEntity").length).toBe(0);
+  });
+});
+
+describe("LocalStore.reconcileRemove", () => {
+  test("returns true when the row existed", () => {
+    const engine = makeEngine();
+    seedStore(engine, "Doc", [{ id: "d1" }]);
+    expect(engine.store.reconcileRemove("Doc", "d1", 10)).toBe(true);
+    expect(engine.store.get("Doc", "d1")).toBeNull();
+  });
+
+  test("returns false when the row didn't exist (no-op)", () => {
+    const engine = makeEngine();
+    expect(engine.store.reconcileRemove("Doc", "missing", 10)).toBe(false);
+  });
+
+  test("tombstone seq bounded by argument, not MAX_SAFE_INTEGER", () => {
+    const engine = makeEngine();
+    seedStore(engine, "Doc", [{ id: "d1" }]);
+    engine.store.reconcileRemove("Doc", "d1", 50);
+
+    // Insert with seq < tombstone → dropped.
+    engine.store.applyChange({
+      seq: 30,
+      entity: "Doc",
+      row_id: "d1",
+      kind: "insert",
+      data: { id: "d1" },
+      timestamp: "",
+    });
+    expect(engine.store.get("Doc", "d1")).toBeNull();
+
+    // Insert with seq > tombstone → accepted.
+    engine.store.applyChange({
+      seq: 100,
+      entity: "Doc",
+      row_id: "d1",
+      kind: "insert",
+      data: { id: "d1", value: "recreated" },
+      timestamp: "",
+    });
+    expect(engine.store.get("Doc", "d1")).not.toBeNull();
+  });
+});
+
+describe("LocalStore.entityNames", () => {
+  test("returns only entities with at least one row", () => {
+    const engine = makeEngine();
+    seedStore(engine, "A", [{ id: "a1" }]);
+    seedStore(engine, "B", [{ id: "b1" }]);
+    seedStore(engine, "C", []);
+    const names = engine.store.entityNames().sort();
+    expect(names).toEqual(["A", "B"]);
+  });
+});

package/tsconfig.json

@@ -1,4 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "types": ["bun-types"]
+  },
   "include": ["src"]
 }