@shipfox/client-auth 0.2.0

package/src/components/workspace-switcher.tsx

@@ -0,0 +1,76 @@
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  CommandSeparator,
+} from '@shipfox/react-ui/command';
+import {Icon} from '@shipfox/react-ui/icon';
+import {useNavigate} from '@tanstack/react-router';
+import {useSetAtom} from 'jotai';
+import {useAuthState} from '#hooks/use-auth-state.js';
+import {lastWorkspaceIdAtom} from '#state/last-workspace.js';
+
+export interface WorkspaceSwitcherProps {
+  activeWorkspaceId: string | undefined;
+  onSelect?: () => void;
+}
+
+export function WorkspaceSwitcher({activeWorkspaceId, onSelect}: WorkspaceSwitcherProps) {
+  const {workspaces} = useAuthState();
+  const navigate = useNavigate();
+  const setLastWorkspaceId = useSetAtom(lastWorkspaceIdAtom);
+
+  const handleSelect = (workspaceId: string) => {
+    try {
+      setLastWorkspaceId(workspaceId);
+    } catch {
+      // localStorage may throw in private browsing or quota-exceeded; persistence is best-effort.
+    }
+    navigate({to: '/workspaces/$wid', params: {wid: workspaceId}});
+    onSelect?.();
+  };
+
+  const handleCreate = () => {
+    navigate({to: '/setup/workspaces/new'});
+    onSelect?.();
+  };
+
+  return (
+    <Command>
+      <CommandInput placeholder="Search workspaces..." />
+      <CommandList className="max-h-none overflow-visible overflow-y-visible p-0">
+        <div className="max-h-300 overflow-y-auto overflow-x-hidden p-4 scrollbar">
+          <CommandEmpty>No workspaces found.</CommandEmpty>
+          <CommandGroup heading="Workspaces">
+            {workspaces.map((workspace) => (
+              <CommandItem
+                key={workspace.id}
+                value={workspace.id}
+                keywords={[workspace.name]}
+                onSelect={() => handleSelect(workspace.id)}
+              >
+                <Icon
+                  name="check"
+                  className={`size-16 mr-8 ${
+                    activeWorkspaceId === workspace.id ? 'opacity-100' : 'opacity-0'
+                  }`}
+                />
+                {workspace.name}
+              </CommandItem>
+            ))}
+          </CommandGroup>
+        </div>
+        <CommandSeparator alwaysRender className="mx-0" />
+        <CommandGroup forceMount className="p-4">
+          <CommandItem value="__create" onSelect={handleCreate} forceMount>
+            <Icon name="addLine" className="size-16" />
+            Create workspace
+          </CommandItem>
+        </CommandGroup>
+      </CommandList>
+    </Command>
+  );
+}

package/src/feature.ts

@@ -0,0 +1,18 @@
+import {defineClientFeature} from '@shipfox/client-shell';
+
+export const authFeature = defineClientFeature({
+  id: 'shipfox.auth',
+  routes: [
+    {path: '/', parent: 'root', impl: '@shipfox/client-auth/routes/index'},
+    {path: '/auth/login', parent: 'root', impl: '@shipfox/client-auth/routes/login'},
+    {path: '/auth/logout', parent: 'root', impl: '@shipfox/client-auth/routes/logout'},
+    {path: '/auth/reset', parent: 'root', impl: '@shipfox/client-auth/routes/reset'},
+    {path: '/auth/signup', parent: 'root', impl: '@shipfox/client-auth/routes/signup'},
+    {path: '/auth/verify-email', parent: 'root', impl: '@shipfox/client-auth/routes/verify-email'},
+    {
+      path: '/setup/workspaces/new',
+      parent: 'root',
+      impl: '@shipfox/client-auth/routes/workspace-onboarding',
+    },
+  ],
+});

package/src/hooks/api/login-auth.test.ts

@@ -0,0 +1,45 @@
+import {configureApiClient} from '@shipfox/client-api';
+import {loginAuth} from './login-auth.js';
+
+function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    headers: {'content-type': 'application/json'},
+    status: 200,
+    ...init,
+  });
+}
+
+describe('loginAuth', () => {
+  beforeEach(() => {
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl: undefined});
+  });
+
+  test('posts login credentials', async () => {
+    let requestBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      requestBody = await (input as Request).clone().json();
+      return jsonResponse({
+        token: 'access-token',
+        user: {
+          id: '11111111-1111-4111-8111-111111111111',
+          email: 'login@example.com',
+          name: null,
+          email_verified_at: '2026-04-27T00:00:00.000Z',
+          status: 'active',
+          created_at: '2026-04-27T00:00:00.000Z',
+          updated_at: '2026-04-27T00:00:00.000Z',
+        },
+      });
+    });
+    configureApiClient({fetchImpl});
+    const body = {email: 'login@example.com', password: 'correct horse'};
+
+    const result = await loginAuth(body);
+
+    const request = fetchImpl.mock.calls[0]?.[0] as Request;
+    expect(result.token).toBe('access-token');
+    expect(request.url).toBe('https://api.example.test/auth/login');
+    expect(request.method).toBe('POST');
+    expect(requestBody).toEqual(body);
+  });
+});

package/src/hooks/api/login-auth.ts

@@ -0,0 +1,41 @@
+import type {LoginBodyDto, LoginResponseDto} from '@shipfox/api-auth-dto';
+import {apiRequest} from '@shipfox/client-api';
+import {useMutation, useQueryClient} from '@tanstack/react-query';
+import {useSetAtom} from 'jotai';
+import {authStateAtom, toAuthenticatedState} from '#state/auth.js';
+import {authRefreshQueryKey} from './refresh-auth.js';
+import {listUserWorkspaces, userWorkspacesQueryKey} from './workspace-auth.js';
+
+export async function loginAuth(body: LoginBodyDto) {
+  return await apiRequest<LoginResponseDto>('/auth/login', {method: 'POST', body});
+}
+
+export function useLoginAuth() {
+  const queryClient = useQueryClient();
+  const setState = useSetAtom(authStateAtom);
+
+  return useMutation({
+    mutationFn: loginAuth,
+    onSuccess: async (result) => {
+      queryClient.setQueryData(authRefreshQueryKey, result);
+      // Resolve workspaces before flipping auth state to authenticated. A
+      // single atomic setState avoids the intermediate window where the user
+      // appears authenticated with zero workspaces, which sent users with
+      // workspaces straight to `/setup/workspaces/new` after form login.
+      let memberships: Awaited<ReturnType<typeof listUserWorkspaces>>['memberships'] = [];
+      try {
+        const workspaces = await queryClient.fetchQuery({
+          queryKey: userWorkspacesQueryKey,
+          queryFn: () => listUserWorkspaces(result.token),
+          retry: false,
+          staleTime: 0,
+        });
+        memberships = workspaces.memberships;
+        queryClient.setQueryData(userWorkspacesQueryKey, workspaces);
+      } catch {
+        // The user is authenticated even if workspace hydration fails.
+      }
+      setState(toAuthenticatedState(result, memberships));
+    },
+  });
+}

package/src/hooks/api/logout-auth.ts

@@ -0,0 +1,26 @@
+import {apiRequest} from '@shipfox/client-api';
+import {useMutation, useQueryClient} from '@tanstack/react-query';
+import {useSetAtom} from 'jotai';
+import {authStateAtom} from '#state/auth.js';
+import {authRefreshQueryKey} from './refresh-auth.js';
+
+async function logoutAuth() {
+  try {
+    await apiRequest<void>('/auth/logout', {method: 'POST', body: {}});
+  } catch {
+    // Logout is best-effort: local session state must clear even if the API is offline.
+  }
+}
+
+export function useLogoutAuth() {
+  const queryClient = useQueryClient();
+  const setState = useSetAtom(authStateAtom);
+
+  return useMutation({
+    mutationFn: logoutAuth,
+    onSettled: () => {
+      setState({status: 'guest'});
+      queryClient.removeQueries({queryKey: authRefreshQueryKey});
+    },
+  });
+}

package/src/hooks/api/password-reset-auth.test.ts

@@ -0,0 +1,68 @@
+import {configureApiClient} from '@shipfox/client-api';
+import {confirmPasswordReset, requestPasswordReset} from './password-reset-auth.js';
+
+function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    headers: {'content-type': 'application/json'},
+    status: 200,
+    ...init,
+  });
+}
+
+describe('requestPasswordReset', () => {
+  beforeEach(() => {
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl: undefined});
+  });
+
+  test('posts reset request emails', async () => {
+    let requestBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      requestBody = await (input as Request).clone().json();
+      return new Response(null, {status: 204});
+    });
+    configureApiClient({fetchImpl});
+
+    const result = await requestPasswordReset({email: 'reset@example.com'});
+
+    const request = fetchImpl.mock.calls[0]?.[0] as Request;
+    expect(result).toBeUndefined();
+    expect(request.url).toBe('https://api.example.test/auth/password-reset');
+    expect(request.method).toBe('POST');
+    expect(requestBody).toEqual({email: 'reset@example.com'});
+  });
+});
+
+describe('confirmPasswordReset', () => {
+  beforeEach(() => {
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl: undefined});
+  });
+
+  test('posts reset confirmation tokens and passwords', async () => {
+    let requestBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      requestBody = await (input as Request).clone().json();
+      return jsonResponse({
+        token: 'reset-access-token',
+        user: {
+          id: '11111111-1111-4111-8111-111111111111',
+          email: 'reset@example.com',
+          name: null,
+          email_verified_at: '2026-04-27T00:00:00.000Z',
+          status: 'active',
+          created_at: '2026-04-27T00:00:00.000Z',
+          updated_at: '2026-04-27T00:00:00.000Z',
+        },
+      });
+    });
+    configureApiClient({fetchImpl});
+    const body = {token: 'reset-token', new_password: 'new password is long'};
+
+    const result = await confirmPasswordReset(body);
+
+    const request = fetchImpl.mock.calls[0]?.[0] as Request;
+    expect(result.token).toBe('reset-access-token');
+    expect(request.url).toBe('https://api.example.test/auth/password-reset/confirm');
+    expect(request.method).toBe('POST');
+    expect(requestBody).toEqual(body);
+  });
+});

package/src/hooks/api/password-reset-auth.ts

@@ -0,0 +1,51 @@
+import type {
+  PasswordResetConfirmBodyDto,
+  PasswordResetConfirmResponseDto,
+  PasswordResetRequestBodyDto,
+} from '@shipfox/api-auth-dto';
+import {apiRequest} from '@shipfox/client-api';
+import {useMutation, useQueryClient} from '@tanstack/react-query';
+import {useSetAtom} from 'jotai';
+import {authStateAtom, toAuthenticatedState} from '#state/auth.js';
+import {authRefreshQueryKey} from './refresh-auth.js';
+import {listUserWorkspaces, userWorkspacesQueryKey} from './workspace-auth.js';
+
+export async function requestPasswordReset(body: PasswordResetRequestBodyDto) {
+  await apiRequest<void>('/auth/password-reset', {method: 'POST', body});
+}
+
+export async function confirmPasswordReset(body: PasswordResetConfirmBodyDto) {
+  return await apiRequest<PasswordResetConfirmResponseDto>('/auth/password-reset/confirm', {
+    method: 'POST',
+    body,
+  });
+}
+
+export function useRequestPasswordResetAuth() {
+  return useMutation({mutationFn: requestPasswordReset});
+}
+
+export function useConfirmPasswordResetAuth() {
+  const queryClient = useQueryClient();
+  const setState = useSetAtom(authStateAtom);
+
+  return useMutation({
+    mutationFn: confirmPasswordReset,
+    onSuccess: async (result) => {
+      setState(toAuthenticatedState(result));
+      queryClient.setQueryData(authRefreshQueryKey, result);
+      try {
+        const workspaces = await queryClient.fetchQuery({
+          queryKey: userWorkspacesQueryKey,
+          queryFn: () => listUserWorkspaces(result.token),
+          retry: false,
+          staleTime: 0,
+        });
+        setState(toAuthenticatedState(result, workspaces.memberships));
+        queryClient.setQueryData(userWorkspacesQueryKey, workspaces);
+      } catch {
+        // The user is authenticated even if workspace hydration fails.
+      }
+    },
+  });
+}

package/src/hooks/api/refresh-auth.test.ts

@@ -0,0 +1,37 @@
+import {getAuthRefreshDelayMs} from './refresh-auth.js';
+
+const BASE64_PADDING_RE = /=+$/;
+
+function jwtWithPayload(payload: unknown): string {
+  const encodedPayload = btoa(JSON.stringify(payload))
+    .replaceAll('+', '-')
+    .replaceAll('/', '_')
+    .replace(BASE64_PADDING_RE, '');
+  return `header.${encodedPayload}.signature`;
+}
+
+describe('getAuthRefreshDelayMs', () => {
+  test('returns the delay five minutes before the token expires', () => {
+    const nowMs = Date.UTC(2026, 3, 29, 12, 0, 0);
+    const token = jwtWithPayload({exp: nowMs / 1000 + 15 * 60});
+
+    const result = getAuthRefreshDelayMs(token, nowMs);
+
+    expect(result).toBe(10 * 60 * 1000);
+  });
+
+  test('returns zero or less for tokens inside the refresh window', () => {
+    const nowMs = Date.UTC(2026, 3, 29, 12, 0, 0);
+    const token = jwtWithPayload({exp: nowMs / 1000 + 4 * 60});
+
+    const result = getAuthRefreshDelayMs(token, nowMs);
+
+    expect(result).toBeLessThanOrEqual(0);
+  });
+
+  test('ignores tokens without a readable expiration claim', () => {
+    const result = getAuthRefreshDelayMs('not-a-jwt', Date.UTC(2026, 3, 29, 12, 0, 0));
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/hooks/api/refresh-auth.ts

@@ -0,0 +1,5 @@
+export {
+  authRefreshQueryKey,
+  getAuthRefreshDelayMs,
+  useRefreshAuth,
+} from '@shipfox/client-shell/runtime';

package/src/hooks/api/signup-auth.ts

@@ -0,0 +1,11 @@
+import type {SignupBodyDto, SignupResponseDto} from '@shipfox/api-auth-dto';
+import {apiRequest} from '@shipfox/client-api';
+import {useMutation} from '@tanstack/react-query';
+
+async function signupAuth(body: SignupBodyDto) {
+  return await apiRequest<SignupResponseDto>('/auth/signup', {method: 'POST', body});
+}
+
+export function useSignupAuth() {
+  return useMutation({mutationFn: signupAuth});
+}

package/src/hooks/api/verify-email-auth.ts

@@ -0,0 +1,55 @@
+import type {
+  VerifyEmailConfirmBodyDto,
+  VerifyEmailConfirmResponseDto,
+  VerifyEmailResendBodyDto,
+  VerifyEmailResendResponseDto,
+} from '@shipfox/api-auth-dto';
+import {apiRequest} from '@shipfox/client-api';
+import {useMutation, useQueryClient} from '@tanstack/react-query';
+import {useSetAtom} from 'jotai';
+import {authStateAtom, toAuthenticatedState} from '#state/auth.js';
+import {authRefreshQueryKey} from './refresh-auth.js';
+import {listUserWorkspaces, userWorkspacesQueryKey} from './workspace-auth.js';
+
+async function verifyEmailAuth(body: VerifyEmailConfirmBodyDto) {
+  return await apiRequest<VerifyEmailConfirmResponseDto>('/auth/verify-email/confirm', {
+    method: 'POST',
+    body,
+  });
+}
+
+async function resendEmailVerificationAuth(body: VerifyEmailResendBodyDto) {
+  return await apiRequest<VerifyEmailResendResponseDto>('/auth/verify-email/resend', {
+    method: 'POST',
+    body,
+  });
+}
+
+export function useResendEmailVerificationAuth() {
+  return useMutation({mutationFn: resendEmailVerificationAuth});
+}
+
+export function useVerifyEmailAuth() {
+  const queryClient = useQueryClient();
+  const setState = useSetAtom(authStateAtom);
+
+  return useMutation({
+    mutationFn: verifyEmailAuth,
+    onSuccess: async (result) => {
+      setState(toAuthenticatedState(result));
+      queryClient.setQueryData(authRefreshQueryKey, result);
+      try {
+        const workspaces = await queryClient.fetchQuery({
+          queryKey: userWorkspacesQueryKey,
+          queryFn: () => listUserWorkspaces(result.token),
+          retry: false,
+          staleTime: 0,
+        });
+        setState(toAuthenticatedState(result, workspaces.memberships));
+        queryClient.setQueryData(userWorkspacesQueryKey, workspaces);
+      } catch {
+        // The user is authenticated even if workspace hydration fails.
+      }
+    },
+  });
+}

package/src/hooks/api/workspace-auth.test.ts

@@ -0,0 +1,40 @@
+import {configureApiClient} from '@shipfox/client-api';
+import {createWorkspace} from './workspace-auth.js';
+
+function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    headers: {'content-type': 'application/json'},
+    status: 200,
+    ...init,
+  });
+}
+
+describe('createWorkspace', () => {
+  beforeEach(() => {
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl: undefined});
+  });
+
+  test('posts the workspace body', async () => {
+    let requestBody: unknown;
+    const fetchImpl = vi.fn(async (input: RequestInfo | URL) => {
+      requestBody = await (input as Request).clone().json();
+      return jsonResponse({
+        id: '33333333-3333-4333-8333-333333333333',
+        name: 'Acme',
+        status: 'active',
+        settings: {},
+        created_at: '2026-04-27T00:00:00.000Z',
+        updated_at: '2026-04-27T00:00:00.000Z',
+      });
+    });
+    configureApiClient({fetchImpl});
+
+    const result = await createWorkspace({name: 'Acme'});
+
+    const request = fetchImpl.mock.calls[0]?.[0] as Request;
+    expect(result.name).toBe('Acme');
+    expect(request.url).toBe('https://api.example.test/workspaces');
+    expect(request.method).toBe('POST');
+    expect(requestBody).toEqual({name: 'Acme'});
+  });
+});

package/src/hooks/api/workspace-auth.ts

@@ -0,0 +1,25 @@
+import type {CreateWorkspaceBodyDto, WorkspaceResponseDto} from '@shipfox/api-workspaces-dto';
+import {apiRequest} from '@shipfox/client-api';
+import {listUserWorkspaces, userWorkspacesQueryKey} from '@shipfox/client-shell/runtime';
+import {useMutation} from '@tanstack/react-query';
+import {useRefreshAuth} from './refresh-auth.js';
+
+export async function createWorkspace(body: CreateWorkspaceBodyDto) {
+  return await apiRequest<WorkspaceResponseDto>('/workspaces', {method: 'POST', body});
+}
+
+export {listUserWorkspaces, userWorkspacesQueryKey};
+
+export function useCreateWorkspaceAuth() {
+  const refreshAuth = useRefreshAuth();
+
+  return useMutation({
+    mutationFn: createWorkspace,
+    onSuccess: async () => {
+      // The new workspace introduces a membership the existing access token
+      // doesn't carry. Refresh so the next request includes it in the JWT
+      // claim and passes the in-memory canAccess() check on the server.
+      await refreshAuth();
+    },
+  });
+}

package/src/hooks/index.ts

@@ -0,0 +1,13 @@
+export {useLoginAuth} from './api/login-auth.js';
+export {useLogoutAuth} from './api/logout-auth.js';
+export {
+  useConfirmPasswordResetAuth,
+  useRequestPasswordResetAuth,
+} from './api/password-reset-auth.js';
+export {useRefreshAuth} from './api/refresh-auth.js';
+export {useSignupAuth} from './api/signup-auth.js';
+export {useResendEmailVerificationAuth, useVerifyEmailAuth} from './api/verify-email-auth.js';
+export {useCreateWorkspaceAuth} from './api/workspace-auth.js';
+export {useActiveWorkspace, useMaybeActiveWorkspace} from './use-active-workspace.js';
+export type {AuthStateValue} from './use-auth-state.js';
+export {useAuthState} from './use-auth-state.js';

package/src/hooks/use-active-workspace.ts

@@ -0,0 +1 @@
+export {useActiveWorkspace, useMaybeActiveWorkspace} from '@shipfox/client-shell/runtime';

package/src/hooks/use-auth-state.ts

@@ -0,0 +1 @@
+export {type AuthStateValue, useAuthState} from '@shipfox/client-shell/runtime';

package/src/index.ts

@@ -0,0 +1,18 @@
+export * from './components/auth-guard.js';
+export * from './components/auth-provider.js';
+export * from './components/auth-shell.js';
+export {WorkspaceCrumb, type WorkspaceCrumbProps} from './components/workspace-crumb.js';
+export {WorkspaceSwitcher, type WorkspaceSwitcherProps} from './components/workspace-switcher.js';
+export * from './hooks/index.js';
+export * from './pages/login-page.js';
+export * from './pages/logout-page.js';
+export * from './pages/password-reset-page.js';
+export * from './pages/signup-page.js';
+export * from './pages/verify-email-page.js';
+export * from './pages/workspace-onboarding-page.js';
+export * from './state/auth.js';
+export {
+  getLastWorkspaceId,
+  lastWorkspaceIdAtom,
+  rememberLastWorkspaceId,
+} from './state/last-workspace.js';

package/src/pages/email-verification-resend-model.test.ts

@@ -0,0 +1,52 @@
+import {EMAIL_VERIFICATION_RESEND_COOLDOWN_SECONDS} from '@shipfox/api-auth-dto';
+import {
+  getLocalResendAvailableAt,
+  getResendRemainingSeconds,
+  parseNextResendAvailableAt,
+} from './email-verification-resend-model.js';
+
+describe('email verification resend model', () => {
+  test('creates local cooldown targets from the shared cooldown', () => {
+    const now = Date.UTC(2026, 4, 11, 12, 0, 0);
+
+    const result = getLocalResendAvailableAt(now);
+
+    expect(result).toBe(now + EMAIL_VERIFICATION_RESEND_COOLDOWN_SECONDS * 1000);
+  });
+
+  test('rounds remaining cooldown seconds up for display', () => {
+    const now = Date.UTC(2026, 4, 11, 12, 0, 0);
+
+    const result = getResendRemainingSeconds({
+      nextResendAvailableAt: now + 1_001,
+      now,
+    });
+
+    expect(result).toBe(2);
+  });
+
+  test('does not return negative remaining cooldown seconds', () => {
+    const now = Date.UTC(2026, 4, 11, 12, 0, 0);
+
+    const result = getResendRemainingSeconds({
+      nextResendAvailableAt: now - 1_000,
+      now,
+    });
+
+    expect(result).toBe(0);
+  });
+
+  test('parses valid server cooldown timestamps', () => {
+    const timestamp = '2026-05-11T12:01:00.000Z';
+
+    const result = parseNextResendAvailableAt(timestamp);
+
+    expect(result).toBe(Date.parse(timestamp));
+  });
+
+  test('ignores invalid server cooldown timestamps', () => {
+    const result = parseNextResendAvailableAt('not-a-date');
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/pages/email-verification-resend-model.ts

@@ -0,0 +1,21 @@
+import {EMAIL_VERIFICATION_RESEND_COOLDOWN_SECONDS} from '@shipfox/api-auth-dto';
+
+export function getLocalResendAvailableAt(now: number): number {
+  return now + EMAIL_VERIFICATION_RESEND_COOLDOWN_SECONDS * 1000;
+}
+
+export function getResendRemainingSeconds(params: {
+  nextResendAvailableAt: number | undefined;
+  now: number;
+}): number {
+  if (!params.nextResendAvailableAt) return 0;
+
+  return Math.max(0, Math.ceil((params.nextResendAvailableAt - params.now) / 1000));
+}
+
+export function parseNextResendAvailableAt(value: string): number | undefined {
+  const nextAvailableAt = Date.parse(value);
+  if (!Number.isFinite(nextAvailableAt)) return undefined;
+
+  return nextAvailableAt;
+}