@vellumai/assistant 0.11.2-dev.202608051637.aae860e → 0.11.2-dev.202608051734.355dff7

package/openapi.yaml

@@ -4615,6 +4615,43 @@ paths:
                 required:
                   - disconnected
                 additionalProperties: false
+  /v1/clients/presence:
+    post:
+      operationId: clients_presence_post
+      summary: Report desktop presence
+      description: Record the desktop presence state reported by the client identified by the X-Vellum-Client-Id header.
+      tags:
+        - clients
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                state:
+                  type: string
+                  enum:
+                    - active
+                    - idle
+                    - away
+                  description: Reported desktop presence state.
+              required:
+                - state
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  recorded:
+                    type: boolean
+                    description: Whether a connected client matched the reporting clientId.
+                required:
+                  - recorded
+                additionalProperties: false
   /v1/config:
     get:
       operationId: config_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608051637.aae860e",
+  "version": "0.11.2-dev.202608051734.355dff7",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/assistant-event-hub.test.ts

@@ -11,6 +11,7 @@ import {
   getReplayWindow,
 } from "../runtime/assistant-stream-state.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { registerHubClient } from "./helpers/hub-clients.js";
 
 function makeEvent(
   overrides: Partial<AssistantEventEnvelope> = {},
@@ -435,6 +436,53 @@ describe("AssistantEventHub — actorPrincipalId on ClientEntry", () => {
   });
 });
 
+// ── ClientEntry desktop presence ─────────────────────────────────────────────
+
+describe("AssistantEventHub client presence", () => {
+  test("records presence on a matching client", () => {
+    const hub = new AssistantEventHub();
+    registerHubClient({ hub, clientId: "mac-1" });
+
+    expect(hub.setClientPresence("mac-1", "active")).toBe(true);
+
+    const presence = hub.getClientById("mac-1")!.presence!;
+    expect(presence.state).toBe("active");
+  });
+
+  test("reportedAt advances on every report", async () => {
+    const hub = new AssistantEventHub();
+    registerHubClient({ hub, clientId: "mac-1" });
+
+    hub.setClientPresence("mac-1", "idle");
+    const first = hub.getClientById("mac-1")!.presence!;
+
+    await Bun.sleep(5);
+    hub.setClientPresence("mac-1", "idle");
+    const second = hub.getClientById("mac-1")!.presence!;
+
+    expect(second.reportedAt.getTime()).toBeGreaterThan(
+      first.reportedAt.getTime(),
+    );
+  });
+
+  test("returns false for an unknown clientId", () => {
+    const hub = new AssistantEventHub();
+    registerHubClient({ hub, clientId: "mac-1" });
+
+    expect(hub.setClientPresence("does-not-exist", "active")).toBe(false);
+    expect(hub.getClientById("mac-1")?.presence).toBeUndefined();
+  });
+
+  test("a disposed client no longer accepts presence", () => {
+    const hub = new AssistantEventHub();
+    registerHubClient({ hub, clientId: "mac-1" });
+
+    expect(hub.disposeClient("mac-1")).toBe(1);
+    expect(hub.setClientPresence("mac-1", "active")).toBe(false);
+    expect(hub.getClientById("mac-1")).toBeUndefined();
+  });
+});
+
 // ── capabilityForMessageType — host-prefix routing ───────────────────────────
 
 describe("capabilityForMessageType — host-prefix routing", () => {

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -65,6 +65,7 @@ import type {
 import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
 import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
 import type { MessageQueue } from "../daemon/conversation-queue-manager.js";
+import { isMacOriginatedUserMessage } from "../persistence/conversation-types.js";
 
 function createWebTurnContext(
   clientOs: string | undefined,
@@ -173,3 +174,101 @@ describe("client OS surface metadata persistence", () => {
     });
   });
 });
+
+/**
+ * `Conversation.clientOs` is a live field that only a transport-carrying
+ * message refreshes, so a transport-less turn stamps whatever an earlier send
+ * left there. `clientOsFromRequest` separates the two, and
+ * {@link isMacOriginatedUserMessage} (the row-origin read behind the
+ * `chat.assistant_reply` presence gate) requires it before letting an attended
+ * Mac suppress a push.
+ */
+describe("client OS per-row evidence marker", () => {
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  test("marks an OS this row's own transport reported", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-transport-os",
+      requestClientOs: "macos",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "macos" });
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
+  });
+
+  test("marks an OS this row's own request headers reported", async () => {
+    const ctx = createWebTurnContext(undefined);
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-header-os",
+      metadata: { client: { os: "macos", interface_version: "0.8.2" } },
+    });
+
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
+  });
+
+  // The bug shape: a button tapped on the phone reaches a conversation whose
+  // last desktop send left `clientOs: "macos"` behind. The row still carries
+  // the inherited OS for telemetry, but nothing says this turn came from the
+  // Mac, so the reply push must survive.
+  test("leaves an inherited OS unmarked and not Mac-originated", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "[User action on card surface: submit]",
+      requestId: "req-inherited-os",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "macos" });
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
+  // The marker vouches for the `client.os` that actually landed, not for
+  // whatever the row reported: a reported OS the stamp disagrees with is no
+  // evidence at all.
+  test("leaves the marker off when the reported OS is not the stamped one", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-mismatched-os",
+      requestClientOs: "ios",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "macos" });
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
+  // The marker is derived from what this persist can see, so a bag value
+  // riding in from a caller must not survive the metadata spread and assert an
+  // origin the row never reported.
+  test("drops a caller-supplied marker from the metadata bag", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "[User action on card surface: submit]",
+      requestId: "req-spoofed-marker",
+      metadata: { clientOsFromRequest: true },
+    });
+
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
+  test("leaves the marker off for a reported OS outside the vocabulary", async () => {
+    const ctx = createWebTurnContext(undefined);
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-unknown-os",
+      requestClientOs: "windows",
+    });
+
+    expect(lastUserMetadata().client).toBeUndefined();
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+  });
+});

package/src/__tests__/conversation-queue.test.ts

@@ -676,6 +676,62 @@ describe("Conversation message queue", () => {
     expect(pendingRuns.length).toBe(3);
   });
 
+  // `Conversation.clientOs` is a live field that only a transport-carrying
+  // message refreshes, so a transport-less drain (a surface action, a signal)
+  // persists the OS of an earlier send. Both rows keep that OS for telemetry;
+  // only the row that reported it claims the surface, which is what stops an
+  // attended Mac from suppressing the push for a button tapped on the phone.
+  test("[experimental] only a queued send that reported its own OS claims that surface", async () => {
+    capturedAddMessages.length = 0;
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "from-the-mac",
+      onEvent: () => {},
+      requestId: "req-mac",
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "macos" },
+    });
+    // A surface action: no transport, so the drain leaves the conversation's
+    // `clientOs` on the macOS value the send above applied.
+    conversation.enqueueMessage({
+      content: "[User action on card surface: submit]",
+      onEvent: () => {},
+      requestId: "req-surface-action",
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+    await resolveRun(1);
+    await waitForPendingRun(3);
+
+    const macRow = capturedAddMessages.find(
+      (m) => m.role === "user" && m.content.includes("from-the-mac"),
+    );
+    expect(macRow).toBeDefined();
+    expect(macRow!.metadata?.client).toEqual({ os: "macos" });
+    expect(macRow!.metadata?.clientOsFromRequest).toBe(true);
+
+    const surfaceActionRow = capturedAddMessages.find(
+      (m) => m.role === "user" && m.content.includes("User action on card"),
+    );
+    expect(surfaceActionRow).toBeDefined();
+    expect(surfaceActionRow!.metadata?.client).toEqual({ os: "macos" });
+    expect(surfaceActionRow!.metadata?.clientOsFromRequest).toBeUndefined();
+
+    await resolveRun(2);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
   test("[experimental] queued passthrough siblings viewing different apps do NOT batch", async () => {
     // A batched turn applies only the head's `visibleAppId`, which drives the
     // `visible_app:` context line. Coalescing messages sent while different

package/src/__tests__/events-dev-bypass-actor.test.ts

@@ -16,13 +16,17 @@
  * principalId at registration time so both sides agree. This keeps targeted
  * host proxy execution working on Docker / platform-managed deployments.
  */
-import { afterAll, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ── Module mocks (must be set up before importing the route) ──────────────
 
 let fakeHttpAuthDisabled = false;
 let fakeGuardianPrincipalId: string | undefined = undefined;
 
+// Manually-resolvable async resolutions, in call order, so tests control
+// exactly when the SSE self-heal lookup completes.
+const pendingAsyncResolutions: Array<(value: string | undefined) => void> = [];
+
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => fakeHttpAuthDisabled,
   hasUngatedHttpAuthDisabled: () => false,
@@ -38,8 +42,21 @@ mock.module("../runtime/local-actor-identity.js", () => ({
     }
     return fakeGuardianPrincipalId;
   },
+  resolveActorPrincipalIdForLocalGuardian: (rawHeader: string | undefined) => {
+    if (rawHeader !== "dev-bypass" || !fakeHttpAuthDisabled) {
+      return Promise.resolve(rawHeader);
+    }
+    return new Promise<string | undefined>((resolve) => {
+      pendingAsyncResolutions.push(resolve);
+    });
+  },
 }));
 
+/** Let the fire-and-forget heal promise chain settle. */
+async function flushMicrotasks(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
 // ── Real imports (after mocks) ────────────────────────────────────────────
 
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
@@ -50,6 +67,10 @@ afterAll(() => {
 });
 
 describe("events SSE registration — dev-bypass actor translation", () => {
+  beforeEach(() => {
+    pendingAsyncResolutions.length = 0;
+  });
+
   test("translates 'dev-bypass' to the real guardian principalId when auth is disabled", () => {
     fakeHttpAuthDisabled = true;
     fakeGuardianPrincipalId = "guardian-real-id";
@@ -104,6 +125,167 @@ describe("events SSE registration — dev-bypass actor translation", () => {
     ac.abort();
   });
 
+  test("self-heals a cold-cache registration once the async guardian lookup resolves", async () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined; // cold cache: sync resolution misses
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "heal-client-001",
+          "x-vellum-interface-id": "chrome-extension",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    // Registered without a principal, heal lookup in flight.
+    expect(hub.getActorPrincipalIdForClient("heal-client-001")).toBeUndefined();
+    expect(pendingAsyncResolutions).toHaveLength(1);
+
+    pendingAsyncResolutions.shift()!("guardian-real-id");
+    await flushMicrotasks();
+
+    // Hub record patched: a host-proxy request registered now snapshots the
+    // real principal, so the result-route same-actor check passes.
+    expect(hub.getActorPrincipalIdForClient("heal-client-001")).toBe(
+      "guardian-real-id",
+    );
+
+    ac.abort();
+  });
+
+  test("does not start the heal lookup when the sync resolution already succeeded", () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = "guardian-real-id"; // warm cache
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "warm-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    expect(pendingAsyncResolutions).toHaveLength(0);
+
+    ac.abort();
+  });
+
+  test("does not start the heal lookup for connections without a dev-bypass principal", () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined;
+
+    const ac = new AbortController();
+    const hub = new AssistantEventHub();
+
+    // Legacy connection with no actor-principal header at all: it registers
+    // without a principal and must stay that way (no dev-bypass translation).
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "legacy-client-001",
+          "x-vellum-interface-id": "macos",
+        },
+        abortSignal: ac.signal,
+      },
+      { hub },
+    );
+
+    expect(pendingAsyncResolutions).toHaveLength(0);
+    expect(
+      hub.getActorPrincipalIdForClient("legacy-client-001"),
+    ).toBeUndefined();
+
+    ac.abort();
+  });
+
+  test("a stale heal cannot patch the subscription that replaced it (reconnect race)", async () => {
+    fakeHttpAuthDisabled = true;
+    fakeGuardianPrincipalId = undefined; // cold cache for the first connect
+
+    const ac1 = new AbortController();
+    const hub = new AssistantEventHub();
+
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "race-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac1.signal,
+      },
+      { hub },
+    );
+    expect(pendingAsyncResolutions).toHaveLength(1);
+    const staleHeal = pendingAsyncResolutions.shift()!;
+
+    // Client reconnects before the first heal resolves; cache is warm now.
+    fakeGuardianPrincipalId = "guardian-current";
+    const ac2 = new AbortController();
+    handleSubscribeAssistantEvents(
+      {
+        headers: {
+          "x-vellum-client-id": "race-client-001",
+          "x-vellum-interface-id": "macos",
+          "x-vellum-actor-principal-id": "dev-bypass",
+        },
+        abortSignal: ac2.signal,
+      },
+      { hub },
+    );
+
+    // The stale heal resolves late with a different value; it is keyed to
+    // the disposed connection, so the live record must be untouched.
+    staleHeal("guardian-stale");
+    await flushMicrotasks();
+
+    expect(hub.getActorPrincipalIdForClient("race-client-001")).toBe(
+      "guardian-current",
+    );
+
+    ac1.abort();
+    ac2.abort();
+  });
+
+  test("fillClientActorPrincipalId never overwrites a present principal", () => {
+    const hub = new AssistantEventHub();
+    const sub = hub.subscribe({
+      type: "client",
+      clientId: "direct-client-001",
+      interfaceId: "macos",
+      capabilities: [],
+      actorPrincipalId: "existing-principal",
+      callback: () => {},
+    });
+
+    hub.fillClientActorPrincipalId(sub.connectionId, "other-principal");
+    expect(hub.getActorPrincipalIdForClient("direct-client-001")).toBe(
+      "existing-principal",
+    );
+
+    // Unknown connection id is a no-op.
+    hub.fillClientActorPrincipalId("conn-does-not-exist", "other-principal");
+    expect(hub.getActorPrincipalIdForClient("direct-client-001")).toBe(
+      "existing-principal",
+    );
+
+    sub.dispose();
+  });
+
   test("does NOT translate when auth is enabled (production mode)", () => {
     // Defense in depth: make sure we never silently rewrite a real
     // principalId that legitimately happens to be the literal "dev-bypass"

package/src/__tests__/helpers/hub-clients.ts

@@ -0,0 +1,42 @@
+/**
+ * Register and tear down client subscribers on an assistant event hub.
+ *
+ * The caller supplies the hub, so this helper holds no runtime import into
+ * `src/` and stays safe for the test preload's import graph.
+ */
+import type { HostProxyCapability, InterfaceId } from "../../channels/types.js";
+import type {
+  AssistantEventHub,
+  DesktopPresenceState,
+} from "../../runtime/assistant-event-hub.js";
+
+export interface RegisterHubClientArgs {
+  hub: AssistantEventHub;
+  clientId: string;
+  interfaceId?: InterfaceId;
+  capabilities?: HostProxyCapability[];
+  actorPrincipalId?: string;
+  /** Reported immediately after subscribing, when supplied. */
+  presence?: DesktopPresenceState;
+}
+
+export function registerHubClient(args: RegisterHubClientArgs): void {
+  const { hub } = args;
+  hub.subscribe({
+    type: "client",
+    clientId: args.clientId,
+    interfaceId: args.interfaceId ?? "macos",
+    capabilities: args.capabilities ?? [],
+    actorPrincipalId: args.actorPrincipalId,
+    callback: () => {},
+  });
+  if (args.presence) {
+    hub.setClientPresence(args.clientId, args.presence);
+  }
+}
+
+export function clearHubClients(hub: AssistantEventHub): void {
+  for (const client of hub.listClients()) {
+    hub.disposeClient(client.clientId);
+  }
+}

package/src/__tests__/host-bash-routes.test.ts

@@ -312,6 +312,73 @@ describe("handleHostBashResult", () => {
     });
   });
 
+  // ── Fill-if-missing: persisted target healed after registration ────
+  //
+  // A request registered while the target's SSE record had no principal
+  // persists `targetActorPrincipalId: undefined`. Once the SSE self-heal
+  // fills the hub record, the result route re-reads the live record,
+  // but ONLY when the persisted value is missing.
+
+  describe("targeted request - missing persisted target principal fills from the live hub record", () => {
+    test("accepts a matching submitter when the hub record was healed after registration", async () => {
+      const requestId = "req-healed-target";
+      // Registered pre-heal: hub had no principal, so nothing was persisted.
+      registerPending(requestId, { targetClientId: "client-abc" });
+      // SSE self-heal fills the hub record afterwards.
+      clientActorPrincipals.set("client-abc", "principal-shared");
+
+      const result = await handleHostBashResult({
+        body: bashBody(requestId),
+        headers: {
+          "x-vellum-client-id": "client-abc",
+          "x-vellum-actor-principal-id": "principal-shared",
+        },
+      });
+
+      expect(result).toEqual({ accepted: true });
+      expect(resolvedIds).toContain(requestId);
+    });
+
+    test("still throws ForbiddenError (403) for a submitter with a different principal than the healed target", () => {
+      const requestId = "req-healed-target-mismatch";
+      registerPending(requestId, { targetClientId: "client-abc" });
+      clientActorPrincipals.set("client-abc", "principal-victim");
+
+      expect(() =>
+        handleHostBashResult({
+          body: bashBody(requestId),
+          headers: {
+            "x-vellum-client-id": "client-abc",
+            "x-vellum-actor-principal-id": "principal-attacker",
+          },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(pendingStore.has(requestId)).toBe(true);
+    });
+
+    test("a present persisted principal always wins over the live hub record", () => {
+      // The fill is missing-only: a persisted value captured at registration
+      // is never overridden, so a submitter matching only the (different)
+      // live record is still rejected.
+      const requestId = "req-persisted-wins";
+      registerPending(requestId, {
+        targetClientId: "client-abc",
+        targetActorPrincipalId: "principal-registration",
+      });
+      clientActorPrincipals.set("client-abc", "principal-live");
+
+      expect(() =>
+        handleHostBashResult({
+          body: bashBody(requestId),
+          headers: {
+            "x-vellum-client-id": "client-abc",
+            "x-vellum-actor-principal-id": "principal-live",
+          },
+        }),
+      ).toThrow(ForbiddenError);
+    });
+  });
+
   // ── Untargeted-request behavior (regression for new check) ─────────
 
   describe("untargeted request — actor principal check is skipped", () => {

package/src/__tests__/http-user-message-parity.test.ts

@@ -650,6 +650,50 @@ describe("HTTP POST /v1/messages client metadata headers", () => {
     ];
     expect(persistOptions.metadata).toBeUndefined();
   });
+
+  // Persistence merges the row's `client.os` from two sources and only one of
+  // them is this row's own: the request. Threading the body's `clientOs` is
+  // what lets it tell a reported OS apart from the one a transport-less turn
+  // inherits off the live conversation.
+  test("threads the body clientOs as this row's own OS evidence", async () => {
+    const persistUserMessage = mock(
+      async (_options: { requestClientOs?: string }) => ({
+        id: "persisted-msg-id",
+        deduplicated: false,
+      }),
+    );
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage("hello", conversation, {
+      clientOs: "macos",
+    });
+
+    expect(res.status).toBe(202);
+    const [persistOptions] = persistUserMessage.mock.calls[0] as unknown as [
+      { requestClientOs?: string },
+    ];
+    expect(persistOptions.requestClientOs).toBe("macos");
+  });
+
+  test("omits the OS evidence when the body reports no clientOs", async () => {
+    const persistUserMessage = mock(
+      async (_options: { requestClientOs?: string }) => ({
+        id: "persisted-msg-id",
+        deduplicated: false,
+      }),
+    );
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage("hello", conversation);
+
+    expect(res.status).toBe(202);
+    const [persistOptions] = persistUserMessage.mock.calls[0] as unknown as [
+      { requestClientOs?: string },
+    ];
+    expect(persistOptions.requestClientOs).toBeUndefined();
+  });
 });
 
 // ============================================================================