gentle-shell-bridge 0.3.0 → 0.3.1

package/test/sidebar-independent.test.ts

@@ -1,349 +0,0 @@
-/**
- * Regressions found by independent review, each pinned before it was fixed.
- *
- * B1 — a sparse `lines()` used to take down its healthy siblings (S8).
- * B2 — a prototype-named id could not round-trip through the visibility map (S5).
- * B3 — the status output grew lines for a row-only session (S12).
- *
- * Plus the review's smaller findings: prune records when the host deletes a part, never let a
- * throwing `setWidget` accessor escape the session handler, and document by behaviour that the
- * rail wrapper spreads own ENUMERABLE fields only.
- */
-
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-
-import {
-  registerSection,
-  resetBusForTests,
-  resetSectionsForTests,
-  snapshotSections,
-} from "../src/bus.ts";
-import { disableCaptureBackend, resetCaptureStateForTests } from "../src/capture.ts";
-import gentleShellBridge, {
-  STATUS_COMMAND,
-  type BridgeCommandContext,
-  type BridgeCommandHandler,
-  type BridgeExtensionApi,
-  type BridgeSessionHandler,
-} from "../src/extension.ts";
-import { resetHookStateForTests } from "../src/hook.ts";
-import { resetRowBuildStateForTests } from "../src/rows.ts";
-import {
-  SIDEBAR_RAIL_KEY,
-  disableSidebarBackend,
-  getSidebarDiagnostics,
-  installSidebarBackend,
-  resetSidebarStateForTests,
-  setRailContributor,
-} from "../src/sidebar.ts";
-import {
-  getSectionFailures,
-  installSectionRail,
-  resetSectionFailuresForTests,
-} from "../src/sidebar-render.ts";
-import { collectStatus, formatStatus } from "../src/status.ts";
-import { resetStoreStateForTests } from "../src/store.ts";
-import type { SidebarSection } from "../src/types.ts";
-import { getSectionVisibility, isSectionVisible, setSectionVisible } from "../src/visibility.ts";
-import { createFakeHost, type FakeHost } from "./fake-host.ts";
-import {
-  cardBody,
-  cardTitles,
-  fakeState,
-  fakeTui,
-  registerNativeFooter,
-  renderSidebar,
-  resetSidebar,
-  type Rail,
-} from "./fake-sidebar.ts";
-
-const HOOK_KEY = Symbol.for("gentle-pi.customize-row-providers");
-const hookSlot = (): Record<symbol, unknown> => globalThis as unknown as Record<symbol, unknown>;
-
-let configHome: string;
-let previousConfigHome: string | undefined;
-
-test.before(() => {
-  configHome = mkdtempSync(join(tmpdir(), "gsb-independent-"));
-  previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
-  process.env.GENTLE_PI_CONFIG_HOME = configHome;
-});
-
-test.after(() => {
-  if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
-  else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
-  rmSync(configHome, { recursive: true, force: true });
-});
-
-test.beforeEach(() => {
-  rmSync(join(configHome, "gentle-shell-bridge"), { recursive: true, force: true });
-  resetBusForTests();
-  resetSectionsForTests();
-  resetSidebar();
-  resetSidebarStateForTests();
-  resetSectionFailuresForTests();
-  resetStoreStateForTests();
-  resetCaptureStateForTests();
-  resetHookStateForTests();
-  resetRowBuildStateForTests();
-  disableCaptureBackend();
-  disableSidebarBackend();
-  setRailContributor(undefined);
-  delete hookSlot()[HOOK_KEY];
-});
-
-const section = (id: string, extra: Partial<SidebarSection> = {}): SidebarSection => ({
-  id,
-  title: id.toUpperCase(),
-  lines: () => [`body ${id}`],
-  ...extra,
-});
-
-const storePath = (): string => join(configHome, "gentle-shell-bridge", "bridge-sections.json");
-
-/** Native part first, then the interception and the section renderer. */
-function arm(): void {
-  registerNativeFooter();
-  installSidebarBackend(() => fakeTui());
-  installSectionRail();
-}
-
-interface Entry {
-  sessionHandlers: BridgeSessionHandler[];
-  commands: Array<{ name: string; handler: BridgeCommandHandler }>;
-}
-
-const loadEntry = (): Entry => {
-  const sessionHandlers: BridgeSessionHandler[] = [];
-  const commands: Entry["commands"] = [];
-  const pi: BridgeExtensionApi = {
-    // `gentle-pi` is present, so `session_start` arms and reports it (S9/T12).
-    getCommands: () => [{ name: "gentle:customize" }],
-    on(_event, handler) {
-      sessionHandlers.push(handler);
-    },
-    registerCommand(name, command) {
-      commands.push({ name, handler: command.handler });
-    },
-  };
-  gentleShellBridge(pi);
-  return { sessionHandlers, commands };
-};
-
-const armThroughEntry = (host: FakeHost): Entry => {
-  const entry = loadEntry();
-  entry.sessionHandlers[0]({}, { hasUI: true, ui: host.ui });
-  return entry;
-};
-
-const printStatus = (entry: Entry): string[] => {
-  const printed: string[] = [];
-  const ctx: BridgeCommandContext = { ui: { notify: (message: string) => printed.push(message) } };
-  entry.commands.find((command) => command.name === STATUS_COMMAND)?.handler("", ctx);
-  return printed.join("\n").split("\n");
-};
-
-// ---------------------------------------------------------------------------------------------
-// B1 — a broken section must never take down its siblings or the whole contribution.
-// ---------------------------------------------------------------------------------------------
-
-test("B1: a sparse lines() loses only its own body and leaves its siblings rendering", () => {
-  registerSection(section("bad", { title: "BAD", lines: () => new Array(2) as unknown as string[] }));
-  registerSection(section("good", { title: "GOOD", lines: () => ["good row"] }));
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "BAD", "GOOD"], "the whole contribution still renders");
-  assert.deepEqual(cardBody("BAD"), [], "the broken body is dropped");
-  assert.deepEqual(cardBody("GOOD"), ["good row"], "the healthy sibling is untouched");
-
-  const failure = getSectionFailures().find((entry) => entry.sectionId === "bad");
-  assert.equal(failure?.phase, "lines");
-  assert.match(failure?.message ?? "", /sparse array/u);
-  assert.deepEqual(
-    getSidebarDiagnostics().lastFailures,
-    [],
-    "the backend never saw a throwing contributor: the failure stayed inside the section",
-  );
-});
-
-test("B1: a hole in the middle of the body is a per-section failure, not a crash", () => {
-  const sparse: string[] = ["first"];
-  sparse[2] = "third"; // length 3, hole at index 1
-  registerSection(section("holey", { title: "HOLEY", lines: () => sparse }));
-  registerSection(section("good", { title: "GOOD", lines: () => ["still here"] }));
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "HOLEY", "GOOD"]);
-  assert.deepEqual(cardBody("HOLEY"), []);
-  assert.deepEqual(cardBody("GOOD"), ["still here"]);
-  assert.match(getSectionFailures().find((e) => e.sectionId === "holey")?.message ?? "", /sparse/u);
-});
-
-test("B1: the backend's own recorded failures reach /bridge-status", () => {
-  registerNativeFooter();
-  installSidebarBackend(() => fakeTui());
-  setRailContributor({
-    render: () => {
-      throw new Error("contributor exploded");
-    },
-  });
-  renderSidebar(40);
-
-  const snapshot = collectStatus();
-  assert.deepEqual(snapshot.sidebarFailures, [
-    { key: "footer", phase: "contribute", message: "contributor exploded" },
-  ]);
-  const lines = formatStatus(snapshot);
-  const at = lines.indexOf("sidebar failures: 1");
-  assert.ok(at !== -1, "the block is emitted");
-  assert.deepEqual(lines.slice(at, at + 2), [
-    "sidebar failures: 1",
-    "  - footer (contribute): contributor exploded",
-  ]);
-});
-
-// ---------------------------------------------------------------------------------------------
-// B2 — prototype-shaped identities must be rejected at the door and survive the store.
-// ---------------------------------------------------------------------------------------------
-
-test("B2: a prototype-shaped or unusable section id is rejected and registers nothing", () => {
-  for (const id of ["__proto__", "constructor", "prototype", "", "   "]) {
-    assert.throws(
-      () => registerSection(section(id)),
-      /invalid section id/u,
-      `id ${JSON.stringify(id)} must be rejected`,
-    );
-  }
-  assert.deepEqual(snapshotSections(), [], "a rejected id must not half-register");
-
-  registerSection(section("ok"));
-  assert.deepEqual(
-    snapshotSections().map((entry) => entry.id),
-    ["ok"],
-    "a valid id still registers afterwards",
-  );
-});
-
-test("B2: visibility survives a prototype-named key and one toggle never erases another", () => {
-  setSectionVisible("__proto__", false);
-  const map = getSectionVisibility();
-  assert.equal(Object.getPrototypeOf(map), null, "no inherited setter can swallow a key");
-  assert.equal(isSectionVisible(map, { id: "__proto__" }), false);
-
-  setSectionVisible("other", true);
-
-  const after = getSectionVisibility();
-  assert.equal(isSectionVisible(after, { id: "__proto__" }), false, "the earlier key survived");
-  assert.equal(isSectionVisible(after, { id: "other" }), true);
-
-  const stored = JSON.parse(readFileSync(storePath(), "utf8"));
-  assert.equal(Object.hasOwn(stored.values.sections, "__proto__"), true);
-  assert.equal(stored.values.sections["__proto__"], false);
-  assert.equal(stored.values.sections.other, true);
-});
-
-// ---------------------------------------------------------------------------------------------
-// B3 — a row-only session must keep the pre-feature output, through the real entry.
-// ---------------------------------------------------------------------------------------------
-
-test("B3: a row-only session through the entry keeps the pre-feature status output", () => {
-  const host = createFakeHost(); // no setWidget: the sidebar cannot arm
-  const entry = armThroughEntry(host);
-  host.buildMenu();
-
-  assert.deepEqual(printStatus(entry), [
-    "gentle-shell-bridge status",
-    "gentle-pi: present",
-    "providers: none",
-    "backend: capture",
-    "last capture: injected 0 rows",
-    "last failures: none",
-    "store problems: none",
-    "duplicate settings: none",
-  ]);
-});
-
-test("B3: the internal Sections provider is never listed, and the rail state only when worth it", () => {
-  registerSection(section("music", { title: "MUSIC" }));
-  const host = createFakeHost();
-  const entry = armThroughEntry(host);
-  host.buildMenu();
-
-  const printed = printStatus(entry);
-  assert.equal(printed.includes("bridge.sections"), false, "bridge plumbing is not a plugin provider");
-  assert.ok(printed.includes("providers: none"));
-  assert.ok(printed.includes("sections: 1"));
-  assert.ok(
-    printed.some((line) => line.startsWith("sidebar: not armed")),
-    "with a section registered, an unreachable rail must be reported",
-  );
-});
-
-// ---------------------------------------------------------------------------------------------
-// The review's smaller findings.
-// ---------------------------------------------------------------------------------------------
-
-test("a part deleted or cleared by the host is no longer reported as wrapped", () => {
-  registerNativeFooter();
-  installSidebarBackend(() => fakeTui());
-  assert.equal(getSidebarDiagnostics().wrappedRails, 1);
-
-  fakeState().parts.delete(SIDEBAR_RAIL_KEY);
-
-  assert.equal(getSidebarDiagnostics().wrappedRails, 0, "a deleted part is not a wrapped rail");
-  assert.equal(collectStatus().sidebar?.rail, "pending");
-
-  registerNativeFooter();
-  installSidebarBackend(() => fakeTui());
-  assert.equal(getSidebarDiagnostics().wrappedRails, 1);
-
-  fakeState().parts.clear();
-
-  assert.equal(getSidebarDiagnostics().wrappedRails, 0, "a cleared map wraps nothing");
-});
-
-test("a throwing setWidget accessor is reported and never escapes the session handler", () => {
-  registerSection(section("music", { title: "MUSIC" }));
-  const host = createFakeHost();
-  Object.defineProperty(host.ui, "setWidget", {
-    configurable: true,
-    get() {
-      throw new Error("ui exploded");
-    },
-  });
-
-  const entry = armThroughEntry(host); // must not throw
-  host.buildMenu();
-
-  assert.ok(host.rendered().includes("music"), "the row side still works");
-  const printed = printStatus(entry);
-  assert.ok(
-    printed.some((line) => line.includes("sidebar: not armed") && line.includes("ui exploded")),
-    `expected an unarmed report with the reason, got: ${printed.join(" | ")}`,
-  );
-});
-
-test("the wrapper carries own enumerable fields only", () => {
-  const prototype = { inheritedMethod: () => "from the prototype" };
-  const rail = Object.create(prototype) as Rail;
-  rail.render = () => ["▾ NATIVE"];
-  let backing = "first";
-  Object.defineProperty(rail, "live", { get: () => backing, enumerable: true });
-  Object.defineProperty(rail, "hiddenField", { value: "not enumerable", enumerable: false });
-  registerNativeFooter(rail);
-
-  installSidebarBackend(() => fakeTui());
-
-  const wrapped = fakeState().parts.get(SIDEBAR_RAIL_KEY) as Record<string, unknown> | undefined;
-  assert.ok(wrapped !== undefined);
-  assert.equal(typeof wrapped.render, "function");
-  assert.equal("inheritedMethod" in wrapped, false, "prototype methods are not carried");
-  assert.equal("hiddenField" in wrapped, false, "non-enumerable fields are not carried");
-  assert.equal(wrapped.live, "first", "a getter is snapshotted when the wrapper is built");
-  backing = "second";
-  assert.equal(wrapped.live, "first", "and it does not track the original afterwards");
-});

package/test/sidebar-render.test.ts

@@ -1,281 +0,0 @@
-/**
- * Section rendering on the host's rail (S3, S7, S8), against the fake host.
- *
- * Every assertion here is about FRAMED output: the bridge contributes rows and card groups, and the
- * host's own frame draws the card. A raw string in a rail's output is not a rendered section.
- */
-
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-
-import { registerSection, resetBusForTests, resetSectionsForTests } from "../src/bus.ts";
-import {
-  SIDEBAR_RAIL_KEY,
-  disableSidebarBackend,
-  installSidebarBackend,
-  resetSidebarStateForTests,
-} from "../src/sidebar.ts";
-import {
-  MAX_SECTION_BODY_ROWS,
-  getSectionFailures,
-  installSectionRail,
-  resetSectionFailuresForTests,
-} from "../src/sidebar-render.ts";
-import { resetStoreStateForTests } from "../src/store.ts";
-import type { SidebarSection } from "../src/types.ts";
-import { setSectionVisible } from "../src/visibility.ts";
-import {
-  cardBody,
-  cardTitles,
-  fakeState,
-  fakeTui,
-  registerNativeFooter,
-  renderSidebar,
-  resetSidebar,
-} from "./fake-sidebar.ts";
-
-let configHome: string;
-let previousConfigHome: string | undefined;
-
-test.before(() => {
-  configHome = mkdtempSync(join(tmpdir(), "gsb-sections-"));
-  previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
-  process.env.GENTLE_PI_CONFIG_HOME = configHome;
-});
-
-test.after(() => {
-  if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
-  else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
-  rmSync(configHome, { recursive: true, force: true });
-});
-
-test.beforeEach(() => {
-  // The visibility store is a real file: each test starts from nothing on disk.
-  rmSync(join(configHome, "gentle-shell-bridge"), { recursive: true, force: true });
-  resetBusForTests();
-  resetSectionsForTests();
-  resetSidebar();
-  resetSidebarStateForTests();
-  resetSectionFailuresForTests();
-  resetStoreStateForTests();
-  disableSidebarBackend();
-});
-
-const section = (id: string, extra: Partial<SidebarSection> = {}): SidebarSection => ({
-  id,
-  title: id.toUpperCase(),
-  lines: () => [`body ${id}`],
-  ...extra,
-});
-
-/** Native host first, then the bridge's interception and the section renderer. */
-function arm(): void {
-  registerNativeFooter();
-  installSidebarBackend(() => fakeTui());
-  installSectionRail();
-}
-
-const rail = () => fakeState().parts.get(SIDEBAR_RAIL_KEY);
-
-test("sections are framed after the native content, in the registered order", () => {
-  // Registered out of order on purpose: the T2 snapshot decides, not insertion order.
-  registerSection(section("weather", { title: "WEATHER", lines: () => ["18° clear"], order: 2 }));
-  registerSection(
-    section("music", {
-      title: "MUSIC",
-      meta: () => "1 playing",
-      lines: () => ["track  one", "album  two"],
-      order: 1,
-    }),
-  );
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "MUSIC", "WEATHER"], "native first, then ordered sections");
-  assert.deepEqual(cardBody("MUSIC"), ["track  one", "album  two"]);
-
-  const heading = renderSidebar().find((row) => row.includes("MUSIC"));
-  assert.ok(heading !== undefined);
-  assert.ok(heading.includes("▾ MUSIC"), "the host's frame carries the section title");
-  assert.ok(heading.includes("1 playing"), "meta() is drawn as the right-aligned count");
-});
-
-test("no body row is ever wider than the width the host passes", () => {
-  registerSection(
-    section("wide", {
-      title: "WIDE",
-      meta: () => "a meta string that cannot possibly fit here",
-      lines: () => ["a body row that is certainly much too long for a narrow rail"],
-    }),
-  );
-  arm();
-
-  const width = 24;
-  const contribution = rail()?.render(width) ?? [];
-  for (const row of contribution) {
-    assert.ok(row.length <= width, `contribution row ${JSON.stringify(row)} exceeds ${width}`);
-  }
-  assert.ok(
-    contribution.some((row) => row.endsWith("…")),
-    "a clipped row is marked, not silently cut",
-  );
-  for (const row of renderSidebar(width)) {
-    // The host leaves one blank row between two sections; every drawn row must fit the width.
-    if (row === "") continue;
-    assert.equal(row.length, width, `framed row ${JSON.stringify(row)} does not fit ${width}`);
-  }
-  assert.ok(cardTitles(width).includes("WIDE"), "the heading survives a width the meta does not fit");
-});
-
-test("the body is capped and says what it elided", () => {
-  const rows = Array.from({ length: MAX_SECTION_BODY_ROWS + 4 }, (_, index) => `row ${index + 1}`);
-  registerSection(section("many", { title: "MANY", lines: () => rows }));
-  arm();
-
-  const body = cardBody("MANY");
-  assert.equal(body.length, MAX_SECTION_BODY_ROWS, "the cap is the contract, not a suggestion");
-  assert.equal(body.at(-1), `… +${rows.length - (MAX_SECTION_BODY_ROWS - 1)} more`);
-});
-
-test("hidden means not built: no card and no lines()/meta() call", () => {
-  let linesCalls = 0;
-  let metaCalls = 0;
-  registerSection(
-    section("quiet", {
-      title: "QUIET",
-      meta: () => {
-        metaCalls += 1;
-        return "quiet";
-      },
-      lines: () => {
-        linesCalls += 1;
-        return ["never built"];
-      },
-    }),
-  );
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "QUIET"]);
-  assert.equal(linesCalls, 1);
-  assert.equal(metaCalls, 1);
-
-  setSectionVisible("quiet", false);
-  linesCalls = 0;
-  metaCalls = 0;
-
-  assert.deepEqual(cardTitles(), ["FOOTER"], "a hidden section is not drawn");
-  assert.equal(linesCalls, 0, "and its body is not built at all");
-  assert.equal(metaCalls, 0, "not even its meta");
-});
-
-test("a throwing lines() drops that body only and is recorded with the section id", () => {
-  registerSection(
-    section("broken", {
-      title: "BROKEN",
-      lines: () => {
-        throw new Error("lines exploded");
-      },
-    }),
-  );
-  registerSection(section("fine", { title: "FINE", lines: () => ["fine row"] }));
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "BROKEN", "FINE"], "both sections still have a heading");
-  assert.deepEqual(cardBody("BROKEN"), [], "the broken body is dropped, not half-drawn");
-  assert.deepEqual(cardBody("FINE"), ["fine row"], "the sibling section is untouched");
-  assert.deepEqual(cardBody("FOOTER"), ["native row 1", "native row 2"]);
-
-  const failure = getSectionFailures().find((entry) => entry.sectionId === "broken");
-  assert.ok(failure !== undefined, "the failure is on record for /bridge-status");
-  assert.equal(failure.phase, "lines");
-  assert.equal(failure.message, "lines exploded");
-});
-
-test("a throwing meta() drops the body too, per the spec's failure rule", () => {
-  registerSection(
-    section("badm", {
-      title: "BADM",
-      meta: () => {
-        throw new Error("meta exploded");
-      },
-      lines: () => ["body that must not be shown"],
-    }),
-  );
-  registerSection(section("good", { title: "GOOD", lines: () => ["good row"] }));
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "BADM", "GOOD"]);
-  assert.deepEqual(cardBody("BADM"), []);
-
-  const failure = getSectionFailures().find((entry) => entry.sectionId === "badm");
-  assert.equal(failure?.phase, "meta");
-  assert.equal(failure?.message, "meta exploded");
-});
-
-test("a non-string line is a failure, never coerced", () => {
-  registerSection(
-    section("bad", {
-      title: "BAD",
-      // The shape is wrong on purpose: a plugin can return anything at runtime.
-      lines: () => ["fine", 42 as unknown as string],
-    }),
-  );
-  arm();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "BAD"]);
-  assert.deepEqual(cardBody("BAD"), []);
-  assert.equal(getSectionFailures().find((entry) => entry.sectionId === "bad")?.phase, "lines");
-});
-
-test("a non-array lines() return is a failure, never coerced", () => {
-  registerSection(
-    section("notarray", {
-      title: "NOTARRAY",
-      lines: () => "just a string" as unknown as string[],
-    }),
-  );
-  arm();
-
-  assert.deepEqual(cardBody("NOTARRAY"), []);
-  assert.equal(getSectionFailures().find((entry) => entry.sectionId === "notarray")?.phase, "lines");
-});
-
-test("a section registered after the first frame appears on the next one", () => {
-  registerSection(section("first", { title: "FIRST" }));
-  arm();
-  assert.deepEqual(cardTitles(), ["FOOTER", "FIRST"]);
-
-  registerSection(section("later", { title: "LATER", order: 1 }));
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "LATER", "FIRST"], "no reinstall, next frame");
-});
-
-test("a disposed section leaves no card and no group behind", () => {
-  const section$ = section("gone", { title: "GONE" });
-  const dispose = registerSection(section$);
-  registerSection(section("stays", { title: "STAYS" }));
-  arm();
-  assert.deepEqual(cardTitles(), ["FOOTER", "GONE", "STAYS"]);
-
-  dispose();
-
-  assert.deepEqual(cardTitles(), ["FOOTER", "STAYS"]);
-});
-
-test("no visible section contributes nothing, leaving the host's own rows untouched", () => {
-  registerSection(section("off", { title: "OFF", defaultVisible: false }));
-  arm();
-
-  assert.deepEqual(rail()?.render(40), ["▾ FOOTER", "native row 1", "native row 2"]);
-  assert.deepEqual(rail()?.cardGroups?.(40), { groups: [{ start: 0, end: 3 }] });
-  assert.deepEqual(cardTitles(), ["FOOTER"]);
-});
-
-test("a non-positive width contributes nothing instead of returning a broken row", () => {
-  registerSection(section("any", { title: "ANY" }));
-  arm();
-
-  assert.deepEqual(rail()?.render(0), ["▾ FOOTER", "native row 1", "native row 2"]);
-});