@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/read-copy-calls.test.ts

@@ -0,0 +1,691 @@
+import { decodeGillOptionsResponse } from "@fungi.computer/gills";
+import { changeDetail, changePage } from "../shared/contract.js";
+import { commitPage, copyRebuildPage } from "@fungi.computer/agar/roles/files";
+import { DatabaseSync } from "node:sqlite";
+import { expect, test } from "vitest";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import type { GitBinding } from "@fungi.computer/agar/git";
+import { gitStore } from "../backend/git.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import { observePush } from "../backend/service.js";
+import { appBackend } from "../backend/methods.js";
+
+function fixture() {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const unavailable = () =>
+    Promise.reject(new Error("Unexpected provider operation"));
+  const base = "a".repeat(40);
+  const head = "b".repeat(40);
+  const commit = (hash: string, parents: string[], message: string) => ({
+    hash,
+    parents,
+    message,
+    treeHash: "c".repeat(40),
+    author: { name: "Levi", email: "levi@test.invalid" },
+    committer: { name: "Levi", email: "levi@test.invalid" },
+    authoredAt: 1,
+    committedAt: 1,
+  });
+  const commits = [commit(head, [base], "Add fish"), commit(base, [], "Start")];
+  const branches = new Map<string, Map<string, string>>();
+  const trees = new Map<
+    string,
+    import("@fungi.computer/agar/git").GitTreeEntry[]
+  >();
+  const blobs = new Map<string, Uint8Array>();
+  const git: GitBinding = {
+    create: (name) =>
+      Promise.resolve({
+        name,
+        defaultBranch: "main",
+        lastPushAt: null,
+        source: null,
+      }),
+    fork: (source, name) =>
+      Promise.resolve({
+        name,
+        defaultBranch: "main",
+        lastPushAt: null,
+        source,
+      }),
+    cloneUrl: (name) => Promise.resolve(`https://git.test/${name}.git`),
+    info: (name) =>
+      Promise.resolve({
+        name,
+        defaultBranch: "main",
+        lastPushAt: null,
+        source: null,
+      }),
+    delete: unavailable,
+    log: (name, options) => {
+      const ref = options.ref;
+      const tip = branches.get(name)?.get(ref) ?? ref;
+      let current = commits.find((commit) => commit.hash === tip);
+      const history: typeof commits = [];
+      while (current !== undefined && history.length < (options.limit ?? 30)) {
+        history.push(current);
+        current = commits.find((commit) => commit.hash === current?.parents[0]);
+      }
+      return Promise.resolve(history);
+    },
+    readCommit: (_repo, hash) =>
+      Promise.resolve(commits.find((commit) => commit.hash === hash) ?? null),
+    readTree: (_repo, hash) => Promise.resolve(trees.get(hash) ?? []),
+    readBlob: (_repo, hash) => Promise.resolve(blobs.get(hash) ?? null),
+    refs: (name) =>
+      Promise.resolve(
+        [...(branches.get(name) ?? [])].map(([ref, hash]) => ({
+          name: `refs/heads/${ref}`,
+          hash,
+        })),
+      ),
+    exchange: unavailable,
+  };
+  const lifetime = new AbortController();
+  const counted = countingGit(git, { limit: 1000, signal: lifetime.signal });
+  const bonsai = {
+    state: new BonsaiState(owner.sql, owner.transactionSync),
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  const call = (
+    method: string,
+    input: import("../shared/contract.js").JsonValue,
+  ) =>
+    appBackend.call(
+      method,
+      input,
+      { bonsai },
+      { actor: { kind: "member", memberId: "Levi" }, computerId: null },
+    );
+  return {
+    database,
+    owner,
+    lifetime,
+    counted,
+    bonsai,
+    call,
+    branches,
+    base,
+    head,
+    commits,
+    trees,
+    blobs,
+  };
+}
+
+test("a repository created in this frame reads its saved copy after reopen without provider operations", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    const before = f.counted.total();
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    const result = await appBackend.call(
+      "repos.get",
+      { repo: "pond" },
+      { bonsai: reopened },
+      { actor: { kind: "member", memberId: "Levi" }, computerId: null },
+    );
+    expect(result).toMatchObject({
+      defaultBranch: "main",
+      empty: true,
+      refs: [],
+      cloneUrl: "https://git.test/pond.git",
+    });
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("accepted pushes prepare Change summaries and details so screens do not call Git", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    f.branches.set("pond", new Map([["main", f.base]]));
+    await f.call("repos.fork", { repo: "pond" });
+    f.branches.set("pond--Levi", new Map([["main", f.head]]));
+    await observePush(f.bonsai, {
+      eventId: "push-work",
+      repository: "pond--Levi",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: [{ ref: "refs/heads/main", before: f.base, after: f.head }],
+    });
+    const before = f.counted.total();
+    expect(await f.call("repos.list", {})).toMatchObject({
+      repos: [{ openChanges: 1 }],
+    });
+    expect(await f.call("changes.list", { repo: "pond" })).toMatchObject({
+      changes: [{ ahead: 1, behind: 0, base: f.base }],
+    });
+    expect(
+      await f.call("changes.get", { repo: "pond", number: 1 }),
+    ).toMatchObject({
+      commits: [{ commit: { hash: f.head } }],
+      diff: { files: [] },
+    });
+    const changesGill = await appBackend.gill(
+      { id: "open-changes", params: { repo: "pond" } },
+      { bonsai: f.bonsai },
+      { actor: { kind: "member", memberId: "Levi" }, computerId: null },
+    );
+    expect(changesGill).toMatchObject({
+      state: "full",
+      rows: [
+        {
+          open: {
+            params: [
+              { key: "page", value: "change" },
+              { key: "repo", value: "pond" },
+              { key: "number", value: "1" },
+            ],
+          },
+        },
+      ],
+    });
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("listing an expired merge lease neither calls Git nor recovers or writes it", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    f.branches.set("pond", new Map([["main", f.base]]));
+    await f.call("repos.fork", { repo: "pond" });
+    f.branches.set("pond--Levi", new Map([["main", f.head]]));
+    await observePush(f.bonsai, {
+      eventId: "leased-work",
+      repository: "pond--Levi",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: [{ ref: "refs/heads/main", before: f.base, after: f.head }],
+    });
+    const row = f.bonsai.state.requireChange("pond", 1);
+    f.bonsai.state.reviseChange(
+      {
+        ...row,
+        state: "merging",
+        lease: {
+          id: "stalled",
+          by: "Levi",
+          head: f.head,
+          at: Date.now() - 120_001,
+        },
+      },
+      row.revision,
+    );
+    const leased = f.bonsai.state.requireChange("pond", 1);
+    const before = f.counted.total();
+    expect(await f.call("changes.list", { repo: "pond" })).toMatchObject({
+      changes: [{ state: "merging" }],
+    });
+    expect(f.counted.total() - before).toBe(0);
+    expect(f.bonsai.state.requireChange("pond", 1)).toEqual(leased);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("opening a Change takes tips from the copy and uses at most two bounded logs", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    f.branches.set(
+      "pond",
+      new Map([
+        ["main", f.base],
+        ["topic", f.head],
+      ]),
+    );
+    await observePush(f.bonsai, {
+      eventId: "topic-work",
+      repository: "pond",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: [
+        { ref: "refs/heads/topic", before: "0".repeat(40), after: f.head },
+      ],
+    });
+    const before = f.counted.counts();
+    expect(
+      await f.call("changes.open", { repo: "pond", sourceRef: "topic" }),
+    ).toMatchObject({ head: f.head, target: f.base });
+    const after = f.counted.counts();
+    expect((after.info ?? 0) - (before.info ?? 0)).toBe(0);
+    expect((after.refs ?? 0) - (before.refs ?? 0)).toBe(0);
+    expect((after.log ?? 0) - (before.log ?? 0)).toBeLessThanOrEqual(2);
+    const reads = f.counted.total();
+    expect(
+      await f.call("changes.get", { repo: "pond", number: 1 }),
+    ).toMatchObject({ change: { head: f.head } });
+    expect(f.counted.total() - reads).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("large Change copies advance in foreground pages with at most 40 provider operations per frame", async () => {
+  const f = fixture();
+  try {
+    const root = "e".repeat(40);
+    const proposed = f.commits[0];
+    if (proposed === undefined)
+      throw new Error("Missing proposed fixture commit");
+    proposed.treeHash = root;
+    const files = Array.from({ length: 60 }, (_, index) => {
+      const hash = (index + 16).toString(16).padStart(40, "0");
+      f.blobs.set(hash, new TextEncoder().encode(`File ${String(index)}\n`));
+      return {
+        name: `${String(index)}.txt`,
+        type: "blob" as const,
+        mode: "100644",
+        hash,
+      };
+    });
+    f.trees.set(root, files);
+    await f.call("repos.create", { name: "pond" });
+    f.branches.set("pond", new Map([["main", f.base]]));
+    await f.call("repos.fork", { repo: "pond" });
+    f.branches.set("pond--Levi", new Map([["main", f.head]]));
+    const beforePush = f.counted.total();
+    await observePush(f.bonsai, {
+      eventId: "large-work",
+      repository: "pond--Levi",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: [{ ref: "refs/heads/main", before: f.base, after: f.head }],
+    });
+    expect(f.counted.total() - beforePush).toBeLessThanOrEqual(40);
+    let cursor: string | null = null;
+    let done = false;
+    let pages = 0;
+    while (!done && pages < 10) {
+      const before = f.counted.total();
+      const result = copyRebuildPage.parse(
+        await f.call("rebuildCopies", { cursor }),
+      );
+      expect(f.counted.total() - before).toBeLessThanOrEqual(40);
+      ({ done, cursor } = result);
+      pages++;
+    }
+    expect(done).toBe(true);
+    const before = f.counted.total();
+    const detail = changeDetail.parse(
+      await f.call("changes.get", { repo: "pond", number: 1 }),
+    );
+    expect(detail.diff.files).toHaveLength(60);
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("opening a pushed merge head uses prepared side ancestry without extra logs", async () => {
+  const f = fixture();
+  try {
+    const proposed = f.commits[0];
+    const initial = f.commits[1];
+    if (!proposed || !initial) throw new Error("Missing fixture history");
+    const side = {
+      ...initial,
+      hash: "d".repeat(40),
+      parents: [f.base],
+      message: "Side work",
+    };
+    proposed.parents.push(side.hash);
+    f.commits.push(side);
+    await f.call("repos.create", { name: "pond" });
+    f.branches.set(
+      "pond",
+      new Map([
+        ["main", f.base],
+        ["topic", f.head],
+      ]),
+    );
+    await observePush(f.bonsai, {
+      eventId: "merged-topic",
+      repository: "pond",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: [
+        { ref: "refs/heads/topic", before: "0".repeat(40), after: f.head },
+      ],
+    });
+    const before = f.counted.counts().log ?? 0;
+    expect(
+      await f.call("changes.open", { repo: "pond", sourceRef: "topic" }),
+    ).toMatchObject({ head: f.head, target: f.base });
+    expect((f.counted.counts().log ?? 0) - before).toBeLessThanOrEqual(2);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("Change pages forward a producer cursor over saved summaries with zero Git and reject a changed snapshot", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    f.branches.set("pond", new Map([["main", f.base]]));
+    await f.call("repos.fork", { repo: "pond" });
+    f.branches.set(
+      "pond--Levi",
+      new Map([
+        ["main", f.base],
+        ...Array.from(
+          { length: 21 },
+          (_, i) => [`fish${String(i)}`, f.head] as const,
+        ),
+      ]),
+    );
+    await observePush(f.bonsai, {
+      repository: "pond--Levi",
+      eventId: "page-changes",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: Array.from({ length: 21 }, (_, i) => ({
+        ref: `refs/heads/fish${String(i)}`,
+        before: "0".repeat(40),
+        after: f.head,
+      })),
+    });
+    const before = f.counted.total();
+    const first = changePage.parse(
+      await f.call("changes.list", { repo: "pond", limit: 20 }),
+    );
+    expect(first.changes).toHaveLength(20);
+    expect(first.changes.map((row) => row.number)).toEqual(
+      Array.from({ length: 20 }, (_, i) => 21 - i),
+    );
+    if (first.next === undefined)
+      throw new Error("First page lacked its cursor");
+    const last = changePage.parse(
+      await f.call("changes.list", {
+        repo: "pond",
+        limit: 20,
+        after: first.next,
+      }),
+    );
+    expect(last.changes.map((row) => row.number)).toEqual([1]);
+    expect(last.next).toBeUndefined();
+    expect(f.counted.total() - before).toBe(0);
+    await expect(
+      f.call("commits.list", {
+        repo: "pond",
+        ref: "main",
+        limit: 20,
+        after: first.next,
+      }),
+    ).rejects.toMatchObject({ code: "invalid" });
+    await f.call("changes.close", { repo: "pond", number: 1 });
+    const changedAt = f.counted.total();
+    await expect(
+      f.call("changes.list", { repo: "pond", limit: 20, after: first.next }),
+    ).rejects.toMatchObject({ code: "conflict" });
+    expect(f.counted.total() - changedAt).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("Commit pages use the saved window at the requested size and reject stale and cross-ref cursors without Git", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    const template = f.commits.at(0);
+    if (template === undefined) throw new Error("Fixture commit missing");
+    let previous = f.head;
+    for (let i = 0; i < 70; i++) {
+      const hash = String(i + 101).padStart(40, "0");
+      f.commits.unshift({
+        ...template,
+        hash,
+        parents: [previous],
+        message: `Fish ${String(i)}`,
+        authoredAt: i + 2,
+        committedAt: i + 2,
+      });
+      previous = hash;
+    }
+    f.branches.set(
+      "pond",
+      new Map([
+        ["main", previous],
+        ["work", previous],
+      ]),
+    );
+    f.bonsai.state.repositoryCopies.stale("pond");
+    await f.call("repos.get", { repo: "pond" });
+    await f.call("commits.list", { repo: "pond", ref: "main" });
+    const before = f.counted.total();
+    const first = commitPage.parse(
+      await f.call("commits.list", { repo: "pond", ref: "main", limit: 20 }),
+    );
+    expect(first.commits).toHaveLength(20);
+    const commitsGill = await appBackend.gill(
+      { id: "recent-commits", params: { repo: "pond", branch: "main" } },
+      { bonsai: f.bonsai },
+      { actor: { kind: "member", memberId: "Levi" }, computerId: null },
+    );
+    if (!("rows" in commitsGill) || commitsGill.state !== "full")
+      throw new Error("Expected a full commit page");
+    expect(commitsGill.rows.map((row) => row.id)).toEqual(
+      first.commits.map((row) => row.commit.hash),
+    );
+    expect(commitsGill.next).toBe(first.next);
+    expect(commitsGill.rows[0]?.open?.params).toEqual([
+      { key: "page", value: "commit" },
+      { key: "repo", value: "pond" },
+      { key: "hash", value: first.commits[0]?.commit.hash },
+    ]);
+    if (first.next === undefined)
+      throw new Error("First page lacked its cursor");
+    let page = first;
+    const hashes = first.commits.map((row) => row.commit.hash);
+    while (page.next !== undefined) {
+      page = commitPage.parse(
+        await f.call("commits.list", {
+          repo: "pond",
+          ref: "main",
+          limit: 20,
+          after: page.next,
+        }),
+      );
+      expect(page.commits.length).toBeLessThanOrEqual(20);
+      hashes.push(...page.commits.map((row) => row.commit.hash));
+    }
+    expect(hashes).toHaveLength(72);
+    expect(new Set(hashes).size).toBe(72);
+    expect(f.counted.total() - before).toBe(0);
+    await expect(
+      f.call("commits.list", {
+        repo: "pond",
+        ref: "work",
+        limit: 20,
+        after: first.next,
+      }),
+    ).rejects.toMatchObject({ code: "invalid" });
+    expect(f.counted.total() - before).toBe(0);
+    f.branches.set("pond", new Map([["main", f.base]]));
+    f.bonsai.state.invalidateRepositoryRefs("pond");
+    await f.call("repos.get", { repo: "pond" });
+    const changedAt = f.counted.total();
+    await expect(
+      f.call("commits.list", {
+        repo: "pond",
+        ref: "main",
+        limit: 20,
+        after: first.next,
+      }),
+    ).rejects.toMatchObject({ code: "conflict" });
+    expect(f.counted.total() - changedAt).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("repository picker pages the saved canonical catalog after facet reconstruction with zero Git", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond", description: "Koi" });
+    await f.call("repos.create", { name: "forest", description: "Trees" });
+    await f.call("repos.fork", { repo: "pond" });
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    const before = f.counted.total();
+    const result = await appBackend.call(
+      "repos.options",
+      { params: {}, limit: 1 },
+      { bonsai: reopened },
+      { actor: { kind: "member", memberId: "Levi" }, computerId: null },
+    );
+    expect(result).toMatchObject({
+      options: [{ value: "forest", label: "forest", detail: "Trees" }],
+    });
+    expect(f.counted.total() - before).toBe(0);
+    expect(appBackend.methods["repos.options"]?.policy).toMatchObject({
+      effect: "read",
+      requires: [],
+    });
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("repository options preserve the caller limit and continuation and refuse a changed catalog cursor", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    await f.call("repos.create", { name: "forest" });
+    const before = f.counted.total();
+    const first = decodeGillOptionsResponse(
+      await f.call("repos.options", { params: {}, limit: 1 }),
+    );
+    expect(first.options).toEqual([{ value: "forest", label: "forest" }]);
+    if (first.next === undefined)
+      throw new Error("Missing picker continuation");
+    expect(
+      decodeGillOptionsResponse(
+        await f.call("repos.options", {
+          params: {},
+          limit: 1,
+          after: first.next,
+        }),
+      ),
+    ).toEqual({ options: [{ value: "pond", label: "pond" }] });
+    expect(f.counted.total() - before).toBe(0);
+    await f.call("repos.create", { name: "lake" });
+    const changed = f.counted.total();
+    await expect(
+      f.call("repos.options", { params: {}, limit: 1, after: first.next }),
+    ).rejects.toMatchObject({ code: "conflict" });
+    expect(f.counted.total() - changed).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("branch options use the chosen repo's saved refs, page without tags and refuse cross-view or changed-ref cursors with zero Git", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    await f.call("repos.create", { name: "forest" });
+    f.branches.set(
+      "pond",
+      new Map([
+        ["main", f.base],
+        ["topic", f.head],
+      ]),
+    );
+    await observePush(f.bonsai, {
+      eventId: "picker-refs",
+      repository: "pond",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+      updates: [
+        { ref: "refs/heads/topic", before: "0".repeat(40), after: f.head },
+      ],
+    });
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.owner.sql, f.owner.transactionSync),
+    };
+    const read = (params: { repo: string }, after?: string) =>
+      appBackend.call(
+        "branches.options",
+        after === undefined
+          ? { params, limit: 1 }
+          : { params, limit: 1, after },
+        { bonsai: reopened },
+        { actor: { kind: "member", memberId: "Levi" }, computerId: null },
+      );
+    const before = f.counted.total();
+    const first = decodeGillOptionsResponse(await read({ repo: "pond" }));
+    expect(first.options).toEqual([{ value: "main", label: "main" }]);
+    if (first.next === undefined)
+      throw new Error("Missing branch continuation");
+    expect(
+      decodeGillOptionsResponse(await read({ repo: "pond" }, first.next)),
+    ).toEqual({ options: [{ value: "topic", label: "topic" }] });
+    await expect(read({ repo: "forest" }, first.next)).rejects.toMatchObject({
+      code: "invalid",
+    });
+    const saved = reopened.state.repositoryCopies.read("pond");
+    if (saved.kind !== "ready") throw new Error("Missing saved refs");
+    reopened.state.repositoryCopies.write("pond", saved.head, {
+      ...saved.value,
+      refs: [...saved.value.refs, { name: "refs/tags/v1", hash: f.base }],
+    });
+    expect(
+      decodeGillOptionsResponse(await read({ repo: "pond" }, first.next))
+        .options,
+    ).toEqual([{ value: "topic", label: "topic" }]);
+    reopened.state.repositoryCopies.write("pond", saved.head, {
+      ...saved.value,
+      refs: [...saved.value.refs, { name: "refs/heads/new", hash: f.base }],
+    });
+    await expect(read({ repo: "pond" }, first.next)).rejects.toMatchObject({
+      code: "conflict",
+    });
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});
+
+test("branch options reject missing or unknown selection and pending saved refs without rebuilding through Git", async () => {
+  const f = fixture();
+  try {
+    await f.call("repos.create", { name: "pond" });
+    const before = f.counted.total();
+    await expect(
+      f.call("branches.options", { params: {}, limit: 20 }),
+    ).rejects.toMatchObject({ code: "invalid" });
+    await expect(
+      f.call("branches.options", { params: { repo: "missing" }, limit: 20 }),
+    ).rejects.toMatchObject({ code: "not_found" });
+    f.bonsai.state.invalidateRepositoryRefs("pond");
+    await expect(
+      f.call("branches.options", { params: { repo: "pond" }, limit: 20 }),
+    ).rejects.toMatchObject({ code: "unavailable" });
+    expect(f.counted.total() - before).toBe(0);
+  } finally {
+    f.lifetime.abort();
+    f.database.close();
+  }
+});