@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -207,7 +207,7 @@ describe("POST inference/provider-connections (create)", () => {
       {
         body: {
           name: "managed-openai",
-          provider: "openai",
+          provider: "vellum",
           auth: { type: "platform" },
         },
       },
@@ -215,6 +215,39 @@ describe("POST inference/provider-connections (create)", () => {
     expect(result.auth).toEqual({ type: "platform" });
   });
 
+  test("rejects platform auth on a real provider", async () => {
+    const err = await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "managed-openai",
+          provider: "openai",
+          auth: { type: "platform" },
+        },
+      },
+    ).catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(BadRequestError);
+    expect((err as BadRequestError).message).toContain("platform");
+    expect((err as BadRequestError).message).toContain("vellum");
+  });
+
+  test("rejects key auth on the vellum provider", async () => {
+    const err = await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "keyed-vellum",
+          provider: "vellum",
+          auth: { type: "api_key", credential: "vault/vellum/key" },
+        },
+      },
+    ).catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(BadRequestError);
+    expect((err as BadRequestError).message).toContain("vellum");
+  });
+
   test("creates connection with none auth (e.g. ollama)", async () => {
     const result = (await call(
       findHandler("inference_provider_connections_create"),
@@ -504,7 +537,7 @@ describe("POST inference/provider-connections (create)", () => {
         body: {
           name: "dup-name",
           provider: "openai",
-          auth: { type: "platform" },
+          auth: { type: "api_key", credential: "vault/openai/key" },
         },
       }),
     ).rejects.toBeInstanceOf(ConflictError);
@@ -585,6 +618,85 @@ describe("PATCH inference/provider-connections/:name (update)", () => {
     ).rejects.toBeInstanceOf(NotFoundError);
   });
 
+  test("rejects switching a real provider's connection to platform auth", async () => {
+    seedConnection({
+      name: "byok-openai",
+      provider: "openai",
+      auth: { type: "api_key", credential: "vault/openai/key" },
+    });
+
+    const err = await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "byok-openai" },
+        body: { auth: { type: "platform" } },
+      },
+    ).catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(BadRequestError);
+    expect((err as BadRequestError).message).toContain("platform");
+  });
+
+  // A persisted row whose provider and auth disagree stays editable: both the
+  // web editor and the CLI resend the stored auth on every edit, so the guard
+  // keys on an actual auth change rather than on the field being present.
+  test("allows editing a legacy mismatched row when the client resends the stored auth", async () => {
+    seedConnection({
+      name: "legacy-managed-openai",
+      provider: "openai",
+      auth: { type: "platform" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "legacy-managed-openai" },
+        body: { auth: { type: "platform" }, label: "Legacy" },
+      },
+    )) as { label: string | null; auth: object };
+    expect(result.label).toBe("Legacy");
+    expect(result.auth).toEqual({ type: "platform" });
+  });
+
+  test("allows editing a legacy mismatched row when auth is omitted", async () => {
+    seedConnection({
+      name: "legacy-managed-gemini",
+      provider: "gemini",
+      auth: { type: "platform" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "legacy-managed-gemini" },
+        body: { label: "Legacy" },
+      },
+    )) as { label: string | null };
+    expect(result.label).toBe("Legacy");
+  });
+
+  // The guard must not trap a legacy row in its mismatched state: an auth
+  // change that repairs the pairing is exactly what should be allowed.
+  test("allows repairing a legacy mismatched row with a valid auth change", async () => {
+    seedConnection({
+      name: "legacy-managed-anthropic",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "legacy-managed-anthropic" },
+        body: { auth: { type: "api_key", credential: "vault/anthropic/key" } },
+      },
+    )) as { auth: object };
+    expect(result.auth).toEqual({
+      type: "api_key",
+      credential: "vault/anthropic/key",
+    });
+  });
+
   test("throws 400 when auth schema is invalid", async () => {
     seedConnection({
       name: "bad-auth",
@@ -971,7 +1083,7 @@ describe("POST with label", () => {
         body: {
           name: "labeled-conn",
           provider: "anthropic",
-          auth: { type: "platform" },
+          auth: { type: "api_key", credential: "vault/anthropic/key" },
           label: "My Anthropic",
         },
       },
@@ -987,7 +1099,7 @@ describe("POST with label", () => {
         body: {
           name: "no-label-conn",
           provider: "openai",
-          auth: { type: "platform" },
+          auth: { type: "api_key", credential: "vault/openai/key" },
         },
       },
     )) as { label: string | null };
@@ -999,7 +1111,7 @@ describe("PATCH with label", () => {
   test("updates label to a string", async () => {
     seedConnection({
       name: "set-label",
-      provider: "openai",
+      provider: "vellum",
       auth: { type: "platform" },
     });
 
@@ -1016,7 +1128,7 @@ describe("PATCH with label", () => {
   test("clears label by setting it to null", async () => {
     seedConnection({
       name: "clear-label",
-      provider: "gemini",
+      provider: "vellum",
       auth: { type: "platform" },
     });
     // First set a label.
@@ -1038,7 +1150,7 @@ describe("PATCH with label", () => {
   test("rejects label: empty string with 400", async () => {
     seedConnection({
       name: "reject-empty",
-      provider: "anthropic",
+      provider: "vellum",
       auth: { type: "platform" },
     });
 
@@ -1168,7 +1280,7 @@ describe("Managed connection write protection", () => {
     test("allows PATCH with auth still set to platform (no-op auth change)", async () => {
       seedConnection({
         name: "vellum",
-        provider: "anthropic",
+        provider: "vellum",
         auth: { type: "platform" },
       });
 
@@ -1190,7 +1302,7 @@ describe("Managed connection write protection", () => {
     test("allows relabeling a managed connection", async () => {
       seedConnection({
         name: "vellum",
-        provider: "openai",
+        provider: "vellum",
         auth: { type: "platform" },
       });
 

package/src/runtime/routes/__tests__/platform-invoice-routes.test.ts

@@ -0,0 +1,392 @@
+/**
+ * Unit tests for the platform_invoices_list and platform_invoices_by_id_get route
+ * handlers: cursor forwarding, page walking, the page cap, and error paths.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnprocessableEntityError,
+} from "../errors.js";
+
+let platformBaseUrl = "https://platform.test";
+let authHeader: string | null = "Api-Key test";
+
+// Spread the real module: replacing it wholesale breaks unrelated importers
+// pulled in by the module under test.
+const actualRegistration =
+  await import("../../../inbound/platform-callback-registration.js");
+mock.module("../../../inbound/platform-callback-registration.js", () => ({
+  ...actualRegistration,
+  resolvePlatformCallbackRegistrationContext: async () => ({
+    isPlatform: false,
+    platformBaseUrl,
+    assistantId: "assistant-123",
+    hasAssistantApiKey: !!authHeader,
+    authHeader,
+    enabled: !!(platformBaseUrl && authHeader),
+  }),
+}));
+
+const { INVOICE_WALK_DEADLINE_MS, MAX_INVOICE_PAGES, ROUTES } =
+  await import("../platform-routes.js");
+
+const listHandler = ROUTES.find(
+  (r) => r.operationId === "platform_invoices_list",
+)!.handler;
+const getHandler = ROUTES.find(
+  (r) => r.operationId === "platform_invoices_by_id_get",
+)!.handler;
+
+const INVOICES_URL = "https://platform.test/v1/organizations/billing/invoices/";
+
+function invoice(id: string) {
+  return {
+    id,
+    number: `INV-${id}`,
+    status: "paid",
+    currency: "usd",
+    amount_due: 1234,
+    amount_paid: 1234,
+    amount_remaining: 0,
+    created: 1750000000,
+    hosted_invoice_url: `https://stripe.test/${id}`,
+    invoice_pdf: null,
+  };
+}
+
+interface FetchCall {
+  url: string;
+  init?: RequestInit;
+}
+
+const realFetch = globalThis.fetch;
+let fetchCalls: FetchCall[] = [];
+
+/** Stub globalThis.fetch, recording calls and answering via `respond`. */
+function stubFetch(
+  respond: (url: string, callIndex: number) => Response | Promise<Response>,
+): void {
+  globalThis.fetch = (async (
+    input: string | URL | Request,
+    init?: RequestInit,
+  ) => {
+    const url =
+      typeof input === "string"
+        ? input
+        : input instanceof URL
+          ? input.toString()
+          : input.url;
+    fetchCalls.push({ url, init });
+    return respond(url, fetchCalls.length - 1);
+  }) as typeof fetch;
+}
+
+/** Await a handler call that must reject, returning the thrown error. */
+async function expectRejection(run: () => unknown): Promise<Error> {
+  try {
+    await run();
+  } catch (err) {
+    return err as Error;
+  }
+  throw new Error("expected rejection");
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+beforeEach(() => {
+  platformBaseUrl = "https://platform.test";
+  authHeader = "Api-Key test";
+  fetchCalls = [];
+});
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+describe("platform_invoices_list", () => {
+  test("returns the platform page and calls the bare invoices URL", async () => {
+    const page = { invoices: [invoice("in_1")], has_more: false };
+    stubFetch(() => jsonResponse(page));
+
+    expect(await listHandler({})).toEqual(page);
+    expect(fetchCalls).toHaveLength(1);
+    expect(fetchCalls[0]!.url).toBe(INVOICES_URL);
+    expect(
+      (fetchCalls[0]!.init?.headers as Record<string, string>).Authorization,
+    ).toBe("Api-Key test");
+  });
+
+  test("forwards starting_after as a cursor and passes has_more through", async () => {
+    const page = { invoices: [invoice("in_2")], has_more: true };
+    stubFetch(() => jsonResponse(page));
+
+    const result = await listHandler({
+      queryParams: { starting_after: "in_a" },
+    });
+
+    expect(fetchCalls[0]!.url).toBe(`${INVOICES_URL}?starting_after=in_a`);
+    expect((result as { has_more: boolean }).has_more).toBe(true);
+  });
+
+  test("rejects with UnprocessableEntityError when credentials are missing", async () => {
+    platformBaseUrl = "";
+    stubFetch(() => jsonResponse({ invoices: [], has_more: false }));
+
+    await expect(listHandler({})).rejects.toBeInstanceOf(
+      UnprocessableEntityError,
+    );
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("resolves an upstream 404 to an empty page", async () => {
+    stubFetch(() => new Response("Not found", { status: 404 }));
+
+    // The platform 404s the invoice list for an organization without invoice
+    // history; that is an empty page, not a server error.
+    expect(await listHandler({})).toEqual({ invoices: [], has_more: false });
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("rejects with InternalError naming the status on a non-OK response", async () => {
+    stubFetch(() => jsonResponse({ detail: "boom" }, 500));
+
+    const err = await expectRejection(() => listHandler({}));
+    expect(err).toBeInstanceOf(InternalError);
+    expect(err.message).toMatch(/HTTP 500/);
+  });
+
+  test("rejects with BadRequestError carrying the detail on an upstream 400", async () => {
+    stubFetch(
+      () => new Response("Invalid starting_after cursor", { status: 400 }),
+    );
+
+    const err = await expectRejection(() =>
+      listHandler({ queryParams: { starting_after: "in_bogus" } }),
+    );
+    expect(err).toBeInstanceOf(BadRequestError);
+    expect(err.message).toMatch(/Invalid starting_after cursor/);
+    expect(err.message).toMatch(
+      /use the id of the last invoice from the previous page/,
+    );
+  });
+
+  test("rejects with InternalError, not BadRequestError, on a 400 without a cursor", async () => {
+    stubFetch(() => new Response("malformed request", { status: 400 }));
+
+    const err = await expectRejection(() => listHandler({}));
+    // Without a caller-supplied starting_after there is nothing
+    // caller-correctable in a 400, so it stays an internal failure.
+    expect(err).not.toBeInstanceOf(BadRequestError);
+    expect(err).toBeInstanceOf(InternalError);
+    expect(err.message).toMatch(/HTTP 400/);
+  });
+});
+
+describe("platform_invoices_by_id_get", () => {
+  test("resolves an invoice found on the first page with one fetch", async () => {
+    const target = invoice("in_target");
+    stubFetch(() =>
+      jsonResponse({ invoices: [invoice("in_1"), target], has_more: false }),
+    );
+
+    expect(await getHandler({ pathParams: { id: "in_target" } })).toEqual(
+      target,
+    );
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("follows the cursor to a later page using the last invoice's id", async () => {
+    const target = invoice("in_target");
+    stubFetch((_url, callIndex) =>
+      callIndex === 0
+        ? jsonResponse({
+            invoices: [invoice("in_a"), invoice("in_b")],
+            has_more: true,
+          })
+        : jsonResponse({ invoices: [target], has_more: false }),
+    );
+
+    expect(await getHandler({ pathParams: { id: "in_target" } })).toEqual(
+      target,
+    );
+    expect(fetchCalls).toHaveLength(2);
+    expect(fetchCalls[1]!.url).toBe(`${INVOICES_URL}?starting_after=in_b`);
+  });
+
+  test("rejects with an actionable NotFoundError when the id is absent", async () => {
+    stubFetch(() =>
+      jsonResponse({ invoices: [invoice("in_other")], has_more: false }),
+    );
+
+    const err = await expectRejection(() =>
+      getHandler({ pathParams: { id: "in_missing" } }),
+    );
+    expect(err).toBeInstanceOf(NotFoundError);
+    expect(err.message).toMatch(
+      /Invoice "in_missing" not found.*assistant platform invoices list/,
+    );
+    // No paging beyond the final (has_more: false) page.
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("rejects with NotFoundError, not InternalError, on an upstream 404", async () => {
+    stubFetch(() => new Response("Not found", { status: 404 }));
+
+    // A 404 from the platform means no invoice history: the walk sees an
+    // empty first page and reports the invoice as not found.
+    const err = await expectRejection(() =>
+      getHandler({ pathParams: { id: "in_missing" } }),
+    );
+    expect(err).not.toBeInstanceOf(InternalError);
+    expect(err).toBeInstanceOf(NotFoundError);
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("stops after MAX_INVOICE_PAGES pages when every page has more", async () => {
+    stubFetch((_url, callIndex) =>
+      jsonResponse({
+        invoices: [invoice(`in_${callIndex}`)],
+        has_more: true,
+      }),
+    );
+
+    await expect(
+      getHandler({ pathParams: { id: "in_never" } }),
+    ).rejects.toBeInstanceOf(InternalError);
+    expect(fetchCalls).toHaveLength(MAX_INVOICE_PAGES);
+  });
+
+  test("stops the cursor walk when the request abort signal fires", async () => {
+    const controller = new AbortController();
+    stubFetch(() => {
+      // Abort after the first page has been served; the handler must not
+      // fetch a second page.
+      controller.abort();
+      return jsonResponse({ invoices: [invoice("in_a")], has_more: true });
+    });
+
+    const err = await expectRejection(() =>
+      getHandler({
+        pathParams: { id: "in_never" },
+        abortSignal: controller.signal,
+      }),
+    );
+    expect(err).toBeInstanceOf(InternalError);
+    expect(err.message).toMatch(/aborted/);
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("rejects with InternalError when the walk exceeds the aggregate deadline", async () => {
+    const realDateNow = Date.now;
+    let now = 0;
+    Date.now = () => now;
+    stubFetch(() => {
+      // Push the clock past the deadline once the first page has been
+      // served; the handler must not fetch a second page.
+      now = INVOICE_WALK_DEADLINE_MS + 1;
+      return jsonResponse({ invoices: [invoice("in_a")], has_more: true });
+    });
+
+    try {
+      const err = await expectRejection(() =>
+        getHandler({ pathParams: { id: "in_never" } }),
+      );
+      expect(err).toBeInstanceOf(InternalError);
+      expect(err.message).toMatch(/timed out after 30 seconds/);
+    } finally {
+      Date.now = realDateNow;
+    }
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("caps the per-page fetch timeout to the remaining walk deadline", async () => {
+    const realDateNow = Date.now;
+    let now = 0;
+    Date.now = () => now;
+    stubFetch((_url, callIndex) => {
+      if (callIndex === 0) {
+        // Leave only 50ms of aggregate budget for the next page.
+        now = INVOICE_WALK_DEADLINE_MS - 50;
+        return jsonResponse({ invoices: [invoice("in_a")], has_more: true });
+      }
+      // Hang until the fetch's combined signal aborts. With the timeout
+      // capped to the remaining 50ms this resolves almost immediately; an
+      // uncapped 10s timeout would blow the assertion on real elapsed time.
+      const signal = fetchCalls[callIndex]!.init?.signal as AbortSignal;
+      return new Promise<Response>((_resolve, reject) => {
+        signal.addEventListener("abort", () => {
+          now = INVOICE_WALK_DEADLINE_MS + 1;
+          reject(signal.reason as Error);
+        });
+      });
+    });
+
+    const startedRealMs = realDateNow();
+    try {
+      const err = await expectRejection(() =>
+        getHandler({ pathParams: { id: "in_never" } }),
+      );
+      expect(err).toBeInstanceOf(InternalError);
+      expect(err.message).toMatch(/timed out after 30 seconds/);
+    } finally {
+      Date.now = realDateNow;
+    }
+    expect(fetchCalls).toHaveLength(2);
+    // The second fetch was cancelled by the capped ~50ms timeout, not the
+    // flat 10s per-request timeout.
+    expect(realDateNow() - startedRealMs).toBeLessThan(5_000);
+  });
+
+  test("threads the request abort signal into the page fetch", async () => {
+    const controller = new AbortController();
+    stubFetch(() =>
+      jsonResponse({ invoices: [invoice("in_target")], has_more: false }),
+    );
+
+    await getHandler({
+      pathParams: { id: "in_target" },
+      abortSignal: controller.signal,
+    });
+
+    // The fetch signal must be derived from the caller's signal: aborting
+    // the request aborts the in-flight platform fetch.
+    const fetchSignal = fetchCalls[0]!.init?.signal as AbortSignal;
+    expect(fetchSignal.aborted).toBe(false);
+    controller.abort();
+    expect(fetchSignal.aborted).toBe(true);
+  });
+
+  test("rejects with InternalError, not BadRequestError, on a 400 mid-walk", async () => {
+    stubFetch((_url, callIndex) =>
+      callIndex === 0
+        ? jsonResponse({ invoices: [invoice("in_a")], has_more: true })
+        : new Response("Invalid starting_after cursor", { status: 400 }),
+    );
+
+    const err = await expectRejection(() =>
+      getHandler({ pathParams: { id: "in_never" } }),
+    );
+    // The walk's cursor is internally generated, so an upstream 400 is an
+    // internal failure rather than a caller input error.
+    expect(err).not.toBeInstanceOf(BadRequestError);
+    expect(err).toBeInstanceOf(InternalError);
+    expect(err.message).toMatch(/HTTP 400/);
+    expect(fetchCalls).toHaveLength(2);
+  });
+
+  test("rejects with BadRequestError when the id path param is missing", async () => {
+    stubFetch(() => jsonResponse({ invoices: [], has_more: false }));
+
+    await expect(getHandler({})).rejects.toBeInstanceOf(BadRequestError);
+    expect(fetchCalls).toHaveLength(0);
+  });
+});

package/src/runtime/routes/__tests__/slack-channel-routes.test.ts

@@ -16,6 +16,13 @@ const originalFetch = globalThis.fetch;
 
 mock.module("../../../security/secure-keys.js", () => ({
   getSecureKeyAsync: async () => "xoxb-test",
+  // The route's import graph (api.ts -> auth.ts -> oauth/*) also reads the
+  // result-shaped accessor; provide it so the mock stays import-complete
+  // even if these static imports ever become dynamic.
+  getSecureKeyResultAsync: async () => ({
+    value: "xoxb-test",
+    unreachable: false,
+  }),
 }));
 
 mock.module("../../sync/sync-publisher.js", () => ({

package/src/runtime/routes/__tests__/workspace-commit-routes.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Request-body validation for the workspace git admin routes.
+ *
+ * Each handler validates its body before touching the workspace git
+ * service, so a malformed body is rejected with a `BadRequestError`
+ * (→ 400) without running any git operation. The handlers are async,
+ * hence the `.rejects` form.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { BadRequestError } from "../errors.js";
+import { ROUTES } from "../workspace-commit-routes.js";
+
+const routeFor = (operationId: string) => {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`no route: ${operationId}`);
+  }
+  return route;
+};
+
+describe("workspace git route body validation", () => {
+  test("workspace_commit rejects a missing message", async () => {
+    await expect(
+      routeFor("workspace_commit").handler({
+        body: {} as Record<string, unknown>,
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("workspace_commit rejects an empty message", async () => {
+    await expect(
+      routeFor("workspace_commit").handler({
+        body: { message: "" } as Record<string, unknown>,
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("workspace_compact_history rejects a non-boolean force", async () => {
+    await expect(
+      routeFor("workspace_compact_history").handler({
+        body: { force: "yes" } as Record<string, unknown>,
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("workspace_compact_history rejects a non-integer retentionDays", async () => {
+    await expect(
+      routeFor("workspace_compact_history").handler({
+        body: { retentionDays: 1.5 } as Record<string, unknown>,
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("workspace_compact_history rejects a non-positive retentionDays", async () => {
+    await expect(
+      routeFor("workspace_compact_history").handler({
+        body: { retentionDays: 0 } as Record<string, unknown>,
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+});

package/src/runtime/routes/consolidation-routes.ts

@@ -22,6 +22,7 @@ import {
   getMessageRoleStatsByConversation,
   listConversationsBySource,
 } from "../../persistence/conversation-queries.js";
+import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../persistence/conversation-types.js";
 import {
   enqueueMemoryJob,
   hasActiveJobOfType,
@@ -29,7 +30,6 @@ import {
 } from "../../persistence/jobs-store.js";
 import { getUsageCostForConversationWindow } from "../../persistence/llm-usage-store.js";
 import { GRAPH_MAINTENANCE_CHECKPOINTS } from "../../plugins/defaults/memory/jobs-worker.js";
-import { MEMORY_V2_CONSOLIDATION_SOURCE } from "../../plugins/defaults/memory/substrate/constants.js";
 import { resolveSubstrateTuning } from "../../plugins/defaults/memory/substrate/tuning.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError } from "./errors.js";