@agent-native/toolkit 0.201.1 → 0.202.0-nightly-20261006033736

package/src/app/shared/ocean/tuning.ts

@@ -0,0 +1,131 @@
+export interface OceanTuning {
+  readonly simulation: {
+    readonly oceanSize: number;
+    readonly worldSize: number;
+    readonly timeScale: number;
+    readonly spectrumTimeScale: number;
+    readonly windSpeed: number;
+    readonly windAngle: number;
+    readonly amplitude: number;
+    readonly choppiness: number;
+    readonly displacementScale: number;
+    readonly foamThreshold: number;
+  };
+  readonly particles: {
+    readonly pointSize: number;
+    readonly fadeNear: number;
+    readonly fadeFar: number;
+    readonly fadePower: number;
+    readonly oceanColor: readonly [number, number, number, number];
+    readonly neonColor: readonly [number, number, number, number];
+    readonly foamColor: readonly [number, number, number, number];
+  };
+  readonly camera: {
+    readonly eye: readonly [number, number, number];
+    readonly target: readonly [number, number, number];
+    readonly pitchDegrees: number;
+    readonly fovDegrees: number;
+    readonly near: number;
+    readonly far: number;
+  };
+  readonly present: {
+    readonly fgColor: readonly [number, number, number];
+    readonly bgColor: readonly [number, number, number];
+    readonly brightness: number;
+  };
+  readonly bloom: {
+    readonly threshold: number;
+    readonly smoothWidth: number;
+    readonly strength: number;
+    readonly radius: number;
+    readonly levels: number;
+    readonly kernelRadii: readonly number[];
+  };
+  readonly bottomFadeStartPercent: number;
+}
+
+const UPSTREAM_TUNING: OceanTuning = {
+  simulation: {
+    oceanSize: 200,
+    worldSize: 400,
+    timeScale: 0.6,
+    spectrumTimeScale: 0.5,
+    windSpeed: 12.9,
+    windAngle: 4.83,
+    amplitude: 1.3,
+    choppiness: 1.51,
+    displacementScale: 0.005,
+    foamThreshold: 0,
+  },
+  particles: {
+    pointSize: 0.75,
+    fadeNear: 60,
+    fadeFar: 250,
+    fadePower: 3.2,
+    oceanColor: [
+      0.003035269835488375, 0.003035269835488375, 0.003035269835488375, 0,
+    ],
+    neonColor: [1, 1, 1, 0],
+    foamColor: [1, 1, 1, 0],
+  },
+  camera: {
+    eye: [0, 30, 90],
+    target: [0, 5, 55],
+    pitchDegrees: -10,
+    fovDegrees: 90,
+    near: 0.1,
+    far: 2000,
+  },
+  present: {
+    fgColor: [0.682, 0.678, 0.671],
+    bgColor: [0.039, 0.039, 0.039],
+    brightness: 2.1,
+  },
+  bloom: {
+    threshold: 0.3,
+    smoothWidth: 0.01,
+    strength: 0.08,
+    radius: 0.46,
+    levels: 5,
+    kernelRadii: [6, 10, 14, 18, 22],
+  },
+  bottomFadeStartPercent: 100,
+};
+
+type Overrides = {
+  [K in keyof OceanTuning]?: OceanTuning[K] extends object
+    ? Partial<OceanTuning[K]>
+    : OceanTuning[K];
+};
+
+const HERO_OVERRIDES: Overrides = {
+  simulation: { worldSize: 700, displacementScale: 0.035 },
+  particles: { pointSize: 1.1, fadeFar: 520, fadePower: 1.8 },
+  camera: {
+    eye: [0, 14, 78],
+    target: [0, 0, -60],
+    pitchDegrees: 21,
+    fovDegrees: 95,
+  },
+  bottomFadeStartPercent: 62,
+};
+
+export const OCEAN_TUNING: OceanTuning = {
+  simulation: { ...UPSTREAM_TUNING.simulation, ...HERO_OVERRIDES.simulation },
+  particles: { ...UPSTREAM_TUNING.particles, ...HERO_OVERRIDES.particles },
+  camera: { ...UPSTREAM_TUNING.camera, ...HERO_OVERRIDES.camera },
+  present: { ...UPSTREAM_TUNING.present, ...HERO_OVERRIDES.present },
+  bloom: { ...UPSTREAM_TUNING.bloom, ...HERO_OVERRIDES.bloom },
+  bottomFadeStartPercent:
+    HERO_OVERRIDES.bottomFadeStartPercent ??
+    UPSTREAM_TUNING.bottomFadeStartPercent,
+};
+
+export function gaussianCoefficients(kernelRadius: number): readonly number[] {
+  return Array.from({ length: 24 }, (_, index) =>
+    index < kernelRadius
+      ? (0.39894 * Math.exp((-0.5 * index * index) / (kernelRadius / 3) ** 2)) /
+        (kernelRadius / 3)
+      : 0,
+  );
+}

package/src/app/shared/ocean/webgpu-support.ts

@@ -0,0 +1,12 @@
+export type WebgpuSupport = "supported" | "unsupported" | "probe-failed";
+
+export async function probeWebgpuSupport(): Promise<WebgpuSupport> {
+  const gpu = (navigator as Navigator & { gpu?: GPU }).gpu;
+  if (!gpu || typeof gpu.requestAdapter !== "function") return "unsupported";
+  try {
+    const adapter = await gpu.requestAdapter();
+    return adapter ? "supported" : "unsupported";
+  } catch {
+    return "probe-failed";
+  }
+}

package/src/app/sharing/AccessRequestApprovalPage.spec.tsx

@@ -0,0 +1,276 @@
+// @vitest-environment happy-dom
+import { AgentNativeI18nProvider } from "@agent-native/core/client/i18n";
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { MemoryRouter, Route, Routes } from "react-router";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createToolkitI18nCatalog } from "../i18n.js";
+import { AccessRequestApprovalPage } from "./AccessRequestApprovalPage.js";
+
+const mocks = vi.hoisted(() => ({
+  query: {} as Record<string, unknown>,
+  queryParams: [] as unknown[],
+  approve: vi.fn(),
+  decline: vi.fn(),
+  refetch: vi.fn(async () => undefined),
+  signOut: vi.fn(async () => undefined),
+}));
+
+vi.mock("@agent-native/core/client/use-action", () => ({
+  useActionQuery: (_name: string, params: unknown) => {
+    mocks.queryParams.push(params);
+    return { refetch: mocks.refetch, ...mocks.query };
+  },
+  useActionMutation: (name: string) => ({
+    mutateAsync:
+      name === "approve-resource-access-request"
+        ? mocks.approve
+        : mocks.decline,
+  }),
+}));
+vi.mock("@agent-native/core/client/hooks", () => ({
+  useSession: () => ({ session: { email: "owner@example.test" } }),
+  signOut: mocks.signOut,
+}));
+vi.mock("@agent-native/core/client/sign-in-return", () => ({
+  buildSignInReturnHref: () => "/_agent-native/sign-in",
+}));
+
+const catalog = createToolkitI18nCatalog({ messages: {} });
+
+const pendingReview = {
+  id: "req-1",
+  generation: 2,
+  state: "pending",
+  requester: { email: "requester@example.test", name: "Pat Example" },
+  note: "Need this for the launch review.",
+  requestedAt: "2026-10-01T10:00:00.000Z",
+  decidedAt: null,
+  grantedRole: null,
+  resource: {
+    type: "document",
+    id: "doc-1",
+    label: "Document",
+    title: "Launch plan",
+    path: "/page/doc-1",
+  },
+};
+
+function actionError(status: number, fields: Record<string, unknown> = {}) {
+  return Object.assign(new Error("Action failed"), { status, ...fields });
+}
+
+describe("AccessRequestApprovalPage", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    mocks.query = {};
+    mocks.queryParams = [];
+    mocks.approve.mockReset().mockResolvedValue(undefined);
+    mocks.decline.mockReset().mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+  });
+
+  function render() {
+    act(() => {
+      root.render(
+        <AgentNativeI18nProvider
+          catalog={catalog}
+          initialLocale="en-US"
+          initialPreference="en-US"
+          persistPreference={false}
+        >
+          <MemoryRouter initialEntries={["/access-requests/req-1"]}>
+            <Routes>
+              <Route
+                path="/access-requests/:requestId"
+                element={<AccessRequestApprovalPage />}
+              />
+            </Routes>
+          </MemoryRouter>
+        </AgentNativeI18nProvider>,
+      );
+    });
+  }
+
+  function button(label: string) {
+    return [...container.querySelectorAll("button")].find(
+      (candidate) => candidate.textContent === label,
+    );
+  }
+
+  it("reads the request from the route without deciding anything", () => {
+    mocks.query = { isLoading: true };
+    render();
+
+    expect(mocks.queryParams.at(-1)).toEqual({ requestId: "req-1" });
+    expect(container.querySelector('[aria-hidden="true"]')).not.toBeNull();
+    expect(mocks.approve).not.toHaveBeenCalled();
+    expect(mocks.decline).not.toHaveBeenCalled();
+  });
+
+  it("shows who is asking, for which page, and starts the role at Viewer", () => {
+    mocks.query = { data: pendingReview };
+    render();
+
+    const heading = container.querySelector("h1");
+    expect(heading?.textContent).toBe("Pat Example is asking for access");
+    expect(document.activeElement).toBe(heading);
+    expect(container.textContent).toContain("requester@example.test");
+    expect(container.textContent).toContain("Need this for the launch review.");
+    const link = container.querySelector("a");
+    expect(link?.getAttribute("href")).toBe("/page/doc-1");
+    expect(link?.textContent).toBe("Launch plan");
+    expect(container.textContent).toContain("Viewer");
+
+    act(() => button("Allow")?.click());
+    expect(mocks.approve).toHaveBeenCalledWith({
+      requestId: "req-1",
+      generation: 2,
+      role: "viewer",
+    });
+  });
+
+  it("declines with the request's generation", () => {
+    mocks.query = { data: pendingReview };
+    render();
+
+    act(() => button("Decline")?.click());
+    expect(mocks.decline).toHaveBeenCalledWith({
+      requestId: "req-1",
+      generation: 2,
+    });
+  });
+
+  it("explains a sharing rule that refused and keeps the request open", async () => {
+    mocks.query = { data: pendingReview };
+    mocks.approve.mockRejectedValue(
+      actionError(403, {
+        actionMessage: "This workspace doesn't allow sharing outside it.",
+      }),
+    );
+    render();
+
+    await act(async () => button("Allow")?.click());
+
+    expect(container.querySelector('[role="alert"]')?.textContent).toBe(
+      "This workspace doesn't allow sharing outside it.",
+    );
+    expect(button("Allow")).toBeDefined();
+  });
+
+  it("reloads a request someone else already handled", async () => {
+    mocks.query = { data: pendingReview };
+    mocks.approve.mockRejectedValue(
+      actionError(409, {
+        errorCode: "access_request_stale",
+        actionMessage: "Someone already handled this request.",
+      }),
+    );
+    render();
+
+    await act(async () => button("Allow")?.click());
+
+    expect(container.querySelector('[role="alert"]')?.textContent).toBe(
+      "Someone already handled this request, or it changed.",
+    );
+    expect(mocks.refetch).toHaveBeenCalled();
+  });
+
+  it("says when the requester couldn't be emailed that they're in", async () => {
+    mocks.query = { data: pendingReview };
+    mocks.approve.mockResolvedValue({
+      state: "approved",
+      role: "viewer",
+      email: "failed",
+    });
+    render();
+
+    await act(async () => button("Allow")?.click());
+
+    expect(container.querySelector('[role="status"]')?.textContent).toMatch(
+      /has access, but we couldn't email them\.$/,
+    );
+  });
+
+  it("doesn't show an unexpected server message", async () => {
+    mocks.query = { data: pendingReview };
+    mocks.approve.mockRejectedValue(
+      actionError(500, { actionMessage: "Internal stack detail" }),
+    );
+    render();
+
+    await act(async () => button("Allow")?.click());
+
+    expect(container.querySelector('[role="alert"]')?.textContent).toBe(
+      "Couldn't save your decision. Try again.",
+    );
+  });
+
+  it("shows the outcome once the request is decided", () => {
+    mocks.query = {
+      data: {
+        ...pendingReview,
+        state: "approved",
+        grantedRole: "editor",
+        decidedAt: "2026-10-01T11:00:00.000Z",
+      },
+    };
+    render();
+
+    expect(container.querySelector("h1")?.textContent).toBe("Access allowed");
+    expect(container.textContent).toContain("Editor");
+    expect(button("Allow")).toBeUndefined();
+    expect(button("Decline")).toBeUndefined();
+  });
+
+  it("shows nothing about the request to someone who can't review it", () => {
+    mocks.query = { isError: true, error: actionError(404) };
+    render();
+
+    expect(container.querySelector("h1")?.textContent).toBe(
+      "You can't review this request",
+    );
+    expect(container.textContent).toContain(
+      "You're signed in as owner@example.test",
+    );
+    expect(container.textContent).not.toContain("Launch plan");
+    expect(button("Allow")).toBeUndefined();
+
+    act(() => button("Switch account")?.click());
+    expect(mocks.signOut).toHaveBeenCalledTimes(1);
+  });
+
+  it("asks a signed-out visitor to sign in", () => {
+    mocks.query = { isError: true, error: actionError(401) };
+    render();
+
+    expect(container.querySelector("h1")?.textContent).toBe(
+      "Sign in to continue",
+    );
+    expect(button("Sign in")).toBeDefined();
+  });
+
+  it("offers Retry when the request couldn't be read", () => {
+    mocks.query = { isError: true, error: actionError(500) };
+    render();
+
+    expect(container.querySelector('[role="alert"]')?.textContent).toBe(
+      "Couldn't load this request.",
+    );
+    act(() => button("Retry")?.click());
+    expect(mocks.refetch).toHaveBeenCalled();
+  });
+});