orizu 0.5.49 → 0.5.50

package/src/http.ts

@@ -1,20 +1,12 @@
 import {
-  clearServerCredentialsIfCurrent,
-  credentialsEqual,
   resolveCredentialServer,
   getActiveBaseUrl,
   getServerCredentials,
   rememberResolvedBearer,
   resolveEnvBearerToken,
-  updateServerCredentialsIfCurrent,
-  withCredentialsTransactionLockAsync,
 } from './credentials.js'
 import { canonicalServerUrl, getFlagBaseUrl, GlobalFlags, normalizeBaseUrl } from './global-flags.js'
-import {
-  describeLogoutHttpFailure,
-  describeLogoutTransportFailure,
-} from './logout-diagnostic.js'
-import { LoginResponse, ServerCredentials, SessionServerCredentials } from './types.js'
+import { ServerCredentials } from './types.js'
 
 let runtimeFlags: GlobalFlags = { local: false, server: null }
 let lastResolvedBaseUrl: string | null = null
@@ -125,199 +117,11 @@ export function assertSecureTokenTransport(baseUrl: string) {
   )
 }
 
-function isSessionCredentials(credentials: ServerCredentials): credentials is SessionServerCredentials {
-  return 'accessToken' in credentials
-}
-
-function getAuthorizationToken(credentials: ServerCredentials): string {
-  return isSessionCredentials(credentials)
-    ? rememberSessionCredentials(credentials).accessToken
-    : rememberResolvedBearer(credentials.apiKey)
-}
-
-function rememberSessionCredentials(
-  credentials: SessionServerCredentials
-): SessionServerCredentials {
-  rememberResolvedBearer(credentials.accessToken)
-  rememberResolvedBearer(credentials.refreshToken)
-  return credentials
-}
-
-function isExpired(expiresAt: number): boolean {
-  const nowUnix = Math.floor(Date.now() / 1000)
-  return expiresAt <= nowUnix + 30
-}
-
-const DEFAULT_CREDENTIALS_REFRESH_TIMEOUT_MS = 10_000
-const MAX_CREDENTIALS_REFRESH_TIMEOUT_MS = 30_000
-const DEFAULT_LOGOUT_TIMEOUT_MS = 10_000
-const MAX_LOGOUT_TIMEOUT_MS = 30_000
-
-function getCredentialsRefreshTimeoutMs(): number {
-  const configured = Number(process.env.ORIZU_CREDENTIALS_REFRESH_TIMEOUT_MS)
-  if (!Number.isSafeInteger(configured) || configured <= 0) {
-    return DEFAULT_CREDENTIALS_REFRESH_TIMEOUT_MS
-  }
-  return Math.min(configured, MAX_CREDENTIALS_REFRESH_TIMEOUT_MS)
-}
-
-function getLogoutTimeoutMs(): number {
-  const configured = Number(process.env.ORIZU_LOGOUT_TIMEOUT_MS)
-  if (!Number.isSafeInteger(configured) || configured <= 0) {
-    return DEFAULT_LOGOUT_TIMEOUT_MS
-  }
-  return Math.min(configured, MAX_LOGOUT_TIMEOUT_MS)
-}
-
-async function withAbortDeadline<T>(
-  operation: (signal: AbortSignal) => Promise<T>,
-  callerSignal: AbortSignal | null | undefined,
-  timeoutMs: number,
-  timeoutError: Error
-): Promise<T> {
-  const controller = new AbortController()
-  const handleCallerAbort = () => controller.abort(callerSignal?.reason)
-  if (callerSignal?.aborted) handleCallerAbort()
-  else callerSignal?.addEventListener('abort', handleCallerAbort, { once: true })
-
-  const timer = setTimeout(() => controller.abort(timeoutError), timeoutMs)
-  const cancellation = new Promise<never>((_resolve, reject) => {
-    const handleAbort = () => reject(controller.signal.reason ?? new Error('Request aborted.'))
-    if (controller.signal.aborted) handleAbort()
-    else controller.signal.addEventListener('abort', handleAbort, { once: true })
-  })
-
-  try {
-    return await Promise.race([operation(controller.signal), cancellation])
-  } finally {
-    clearTimeout(timer)
-    callerSignal?.removeEventListener('abort', handleCallerAbort)
-  }
-}
-
-async function withCredentialsRefreshDeadline<T>(
-  operation: (signal: AbortSignal) => Promise<T>,
-  callerSignal?: AbortSignal | null
-): Promise<T> {
-  const timeoutMs = getCredentialsRefreshTimeoutMs()
-  const timeoutError = new Error(
-    `ORIZU_CREDENTIALS_REFRESH_TIMEOUT: session refresh exceeded ${timeoutMs}ms.`
-  )
-  return await withAbortDeadline(operation, callerSignal, timeoutMs, timeoutError)
-}
-
-async function withLogoutDeadline<T>(
-  operation: (signal: AbortSignal) => Promise<T>,
-  callerSignal?: AbortSignal | null
-): Promise<T> {
-  const timeoutMs = getLogoutTimeoutMs()
-  const timeoutError = new Error(
-    `ORIZU_LOGOUT_TIMEOUT: remote logout exceeded ${timeoutMs}ms.`
-  )
-  timeoutError.name = 'TimeoutError'
-  return await withAbortDeadline(operation, callerSignal, timeoutMs, timeoutError)
-}
-
 export function credentialRequestRedirectPolicy(): Pick<RequestInit, 'redirect'> {
   return process.env.ORIZU_CLI_AUTH_REDIRECT === 'error' ? { redirect: 'error' } : {}
 }
 
-async function refreshCredentials(
-  baseUrl: string,
-  credentials: ServerCredentials,
-  callerSignal?: AbortSignal | null
-): Promise<ServerCredentials> {
-  if (!isSessionCredentials(credentials)) {
-    throw new Error('API key credentials do not refresh. Run `orizu login` again if access fails.')
-  }
-
-  assertSecureTokenTransport(baseUrl)
-  const refreshToken = rememberResolvedBearer(credentials.refreshToken)
-  const data = await withCredentialsRefreshDeadline(async signal => {
-    const response = await fetch(`${baseUrl}/api/cli/auth/refresh`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ refreshToken }),
-      ...credentialRequestRedirectPolicy(),
-      signal,
-    })
-
-    if (!response.ok) {
-      throw new Error('Session expired. Run `orizu login` again.')
-    }
-    return await response.json() as LoginResponse
-  }, callerSignal)
-  if (!data.accessToken || !data.refreshToken || !data.expiresAt) {
-    throw new Error('Server returned invalid refresh credentials. Run `orizu login` again.')
-  }
-
-  const refreshed = rememberSessionCredentials({
-    credentialType: 'session' as const,
-    accessToken: data.accessToken,
-    refreshToken: data.refreshToken,
-    expiresAt: data.expiresAt,
-  })
-  if (isExpired(refreshed.expiresAt)) {
-    throw new Error(
-      'ORIZU_CREDENTIALS_REFRESH_UNUSABLE: refreshed session expires within the 30-second safety window.'
-    )
-  }
-  return refreshed
-}
-
-interface StoredRefreshResult {
-  status: 'refreshed' | 'changed'
-  credentials: ServerCredentials | null
-}
-
-async function refreshStoredCredentialsIfCurrent(
-  baseUrl: string,
-  expected: ServerCredentials,
-  callerSignal?: AbortSignal | null
-): Promise<StoredRefreshResult> {
-  return await withCredentialsTransactionLockAsync(async () => {
-    const current = getServerCredentials(baseUrl)
-    if (!current || !credentialsEqual(current, expected)) {
-      return { status: 'changed', credentials: current }
-    }
-
-    const refreshed = await refreshCredentials(baseUrl, expected, callerSignal)
-    if (!updateServerCredentialsIfCurrent(baseUrl, expected, refreshed)) {
-      return { status: 'changed', credentials: getServerCredentials(baseUrl) }
-    }
-    return { status: 'refreshed', credentials: refreshed }
-  })
-}
-
-function requireCurrentCredentials(baseUrl: string, credentials: ServerCredentials | null): ServerCredentials {
-  if (credentials) return credentials
-  throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`)
-}
-
-interface ResolvedStoredCredentials {
-  credentials: ServerCredentials
-  didRefresh: boolean
-}
-
-async function refreshExpiredStoredCredentials(
-  baseUrl: string,
-  initial: ServerCredentials,
-  callerSignal?: AbortSignal | null
-): Promise<ResolvedStoredCredentials> {
-  if (!isSessionCredentials(initial) || !isExpired(initial.expiresAt)) {
-    return { credentials: initial, didRefresh: false }
-  }
-  const result = await refreshStoredCredentialsIfCurrent(baseUrl, initial, callerSignal)
-  if (result.status === 'changed') {
-    throw new Error(
-      'ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed before this request began; the request was not sent.'
-    )
-  }
-  return {
-    credentials: requireCurrentCredentials(baseUrl, result.credentials),
-    didRefresh: true,
-  }
-}
+const storedSessionRequests = () => import('./stored-session-requests.js')
 
 export type AuthenticatedRequestSource = 'ORIZU_TOKEN' | 'ORIZU_TOKEN_FILE' | 'stored'
 
@@ -334,6 +138,10 @@ export interface LogoutResult {
   localCredentialCleared: boolean
 }
 
+function notLoggedIn(baseUrl: string): Error {
+  return new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`)
+}
+
 /**
  * Captures one authenticated server context for a multi-step operation. The
  * returned interface intentionally exposes no credential material. Its closure
@@ -387,95 +195,42 @@ export function captureAuthenticatedRequestContext(
   }
 
   const capturedCredentials = getServerCredentials(baseUrl)
-  if (!capturedCredentials) {
-    throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`)
-  }
-  void getAuthorizationToken(capturedCredentials)
+  if (!capturedCredentials) throw notLoggedIn(baseUrl)
+  rememberStoredBearers(capturedCredentials)
   let activeCredentials = capturedCredentials
-
-  async function refreshCapturedCredentials(callerSignal?: AbortSignal | null): Promise<void> {
-    const result = await refreshStoredCredentialsIfCurrent(baseUrl, activeCredentials, callerSignal)
-    if (result.status === 'changed') {
-      throw new Error(
-        'ORIZU_CREDENTIALS_CHANGED: stored credentials changed before the captured session could refresh. Reconfirm the account and retry.'
-      )
-    }
-    activeCredentials = requireCurrentCredentials(baseUrl, result.credentials)
-  }
+  const changed = 'ORIZU_CREDENTIALS_CHANGED: stored credentials changed before the captured session could refresh. Reconfirm the account and retry.'
 
   return {
     baseUrl,
     source: 'stored',
     async fetch(path: string, init: RequestInit = {}, onRequestStart?: () => void) {
-      let didRefresh = false
-      if (
-        allowRefresh
-        && isSessionCredentials(activeCredentials)
-        && isExpired(activeCredentials.expiresAt)
-      ) {
-        await refreshCapturedCredentials(init.signal)
-        didRefresh = true
-      }
-
-      onRequestStart?.()
-      let response = await fetch(`${baseUrl}${path}`, {
-        ...init,
-        headers: {
-          ...(init.headers || {}),
-          Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-        },
-        ...credentialRequestRedirectPolicy(),
-      })
-
-      if (
-        allowRefresh
-        && response.status === 401
-        && isSessionCredentials(activeCredentials)
-        && !didRefresh
-      ) {
-        await refreshCapturedCredentials(init.signal)
-        onRequestStart?.()
-        response = await fetch(`${baseUrl}${path}`, {
-          ...init,
-          headers: {
-            ...(init.headers || {}),
-            Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-          },
-          ...credentialRequestRedirectPolicy(),
-        })
-      }
-      return response
+      const { storedRequest } = await storedSessionRequests()
+      return await storedRequest({
+        baseUrl,
+        credentials: activeCredentials,
+        allowRefresh,
+        changedBeforeRequest: changed,
+        changedBeforeReplay: changed,
+        onRefreshed: refreshed => { activeCredentials = refreshed },
+      }, path, init, onRequestStart)
     },
     async logout(callerSignal?: AbortSignal | null) {
-      const authorizationToken = getAuthorizationToken(activeCredentials)
-      const refreshToken = isSessionCredentials(activeCredentials)
-        ? rememberResolvedBearer(activeCredentials.refreshToken)
-        : null
-      const secrets = [authorizationToken, ...(refreshToken !== null ? [refreshToken] : [])]
-      let remoteLogoutReason: string | null = null
-      try {
-        remoteLogoutReason = await withLogoutDeadline(async signal => {
-          const response = await fetch(`${baseUrl}/api/cli/auth/logout`, {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              Authorization: `Bearer ${authorizationToken}`,
-            },
-            body: refreshToken !== null ? JSON.stringify({ refreshToken }) : undefined,
-            ...credentialRequestRedirectPolicy(),
-            signal,
-          })
-          return response.ok ? null : await describeLogoutHttpFailure(response, secrets)
-        }, callerSignal)
-      } catch (error) {
-        remoteLogoutReason = describeLogoutTransportFailure(error, secrets)
-      }
-      const localCredentialCleared = clearServerCredentialsIfCurrent(baseUrl, activeCredentials)
-      return { remoteError: remoteLogoutReason, localCredentialCleared }
+      const { storedLogout } = await storedSessionRequests()
+      return await storedLogout(baseUrl, baseUrl, activeCredentials, callerSignal)
     },
   }
 }
 
+// Redacts a stored login from diagnostics from the moment it is read.
+function rememberStoredBearers(credentials: ServerCredentials): void {
+  if ('accessToken' in credentials) {
+    rememberResolvedBearer(credentials.accessToken)
+    rememberResolvedBearer(credentials.refreshToken)
+  } else {
+    rememberResolvedBearer(credentials.apiKey)
+  }
+}
+
 // The optional observer runs immediately before a resource fetch, after auth
 // preflight. Authentication refresh requests do not mark the resource as sent.
 export async function authedFetch(path: string, init: RequestInit = {}, onRequestStart?: () => void) {
@@ -504,47 +259,14 @@ export async function authedFetch(path: string, init: RequestInit = {}, onReques
   }
 
   const credentials = getServerCredentials(baseUrl)
-  if (!credentials) {
-    throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`)
-  }
-
-  const resolved = await refreshExpiredStoredCredentials(baseUrl, credentials, init.signal)
-  let activeCredentials = resolved.credentials
-
-  let response = await fetchResource(`${baseUrl}${path}`, {
-    ...init,
-    headers: {
-      ...(init.headers || {}),
-      Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-    },
-    ...credentialRequestRedirectPolicy(),
-  })
-
-  if (
-    response.status === 401
-    && isSessionCredentials(activeCredentials)
-    && !resolved.didRefresh
-  ) {
-    const refreshResult = await refreshStoredCredentialsIfCurrent(
-      baseUrl,
-      activeCredentials,
-      init.signal
-    )
-    if (refreshResult.status === 'changed') {
-      throw new Error(
-        'ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed after this request began; the request was not replayed.'
-      )
-    }
-    activeCredentials = requireCurrentCredentials(baseUrl, refreshResult.credentials)
-    response = await fetchResource(`${baseUrl}${path}`, {
-      ...init,
-      headers: {
-        ...(init.headers || {}),
-        Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-      },
-      ...credentialRequestRedirectPolicy(),
-    })
-  }
+  if (!credentials) throw notLoggedIn(baseUrl)
 
-  return response
+  const { storedRequest } = await storedSessionRequests()
+  return await storedRequest({
+    baseUrl,
+    credentials,
+    allowRefresh: true,
+    changedBeforeRequest: 'ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed before this request began; the request was not sent.',
+    changedBeforeReplay: 'ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed after this request began; the request was not replayed.',
+  }, path, init, onRequestStart)
 }

package/src/keyboard-select.ts

@@ -1,23 +1,12 @@
-import { emitKeypressEvents } from 'readline'
 import { stdin as input, stdout as output } from 'process'
 
 import { sanitizeTerminalText } from './json-response.js'
 
-interface KeypressInfo {
-  name?: string
-  ctrl?: boolean
-}
-
 interface KeyboardSelectOptions<T> {
   onEscape?: () => T
   escapeLabel?: string
 }
 
-type RawInput = typeof input & {
-  setRawMode?: (mode: boolean) => void
-  isRaw?: boolean
-}
-
 export async function promptKeyboardSelect<T>(
   title: string,
   items: T[],
@@ -36,9 +25,6 @@ export async function promptKeyboardSelect<T>(
 
   let selected = 0
   let rendered = false
-  const rawInput = input as RawInput
-  const wasRaw = Boolean(rawInput.isRaw)
-  emitKeypressEvents(input)
 
   function render() {
     if (rendered) output.write(`\x1b[${items.length}A`)
@@ -51,47 +37,24 @@ export async function promptKeyboardSelect<T>(
   }
 
   render()
-  output.write('\x1b[?25l')
-
-  return new Promise((resolvePromise, rejectPromise) => {
-    function cleanup() {
-      input.off('keypress', onKeypress)
-      if (rawInput.setRawMode && !wasRaw) rawInput.setRawMode(false)
-      input.pause()
-      output.write('\x1b[?25h\n')
-    }
-
-    function onKeypress(_chunk: string, key: KeypressInfo) {
-      if (key.ctrl && key.name === 'c') {
-        cleanup()
-        rejectPromise(new Error('Setup cancelled.'))
-        return
-      }
-      if (key.name === 'escape') {
-        cleanup()
-        if (options?.onEscape) resolvePromise(options.onEscape())
-        else rejectPromise(new Error('Setup cancelled.'))
-        return
-      }
-      if (key.name === 'up') {
-        selected = (selected - 1 + items.length) % items.length
-        render()
-        return
-      }
-      if (key.name === 'down') {
-        selected = (selected + 1) % items.length
+  const onEscape = options?.onEscape
+  const { readKeys } = await import('./terminal-key-session.js')
+  let choice: { item: T } | { escaped: true }
+  try {
+    choice = await readKeys<{ item: T } | { escaped: true }>(key => {
+      if (key.name === 'escape') return onEscape ? { kind: 'done', value: { escaped: true } } : { kind: 'cancel' }
+      if (key.name === 'up' || key.name === 'down') {
+        selected = (selected + (key.name === 'up' ? -1 : 1) + items.length) % items.length
         render()
-        return
+        return { kind: 'wait' }
       }
-      if (key.name === 'return' || key.name === 'enter') {
-        const item = items[selected]
-        cleanup()
-        resolvePromise(item)
-      }
-    }
-
-    input.on('keypress', onKeypress)
-    input.resume()
-    rawInput.setRawMode?.(true)
-  })
+      if (key.name === 'return' || key.name === 'enter') return { kind: 'done', value: { item: items[selected] } }
+      return { kind: 'wait' }
+    }, { hideCursor: true })
+  } finally {
+    output.write('\n')
+  }
+  if ('item' in choice) return choice.item
+  if (!onEscape) throw new Error('Setup cancelled.')
+  return onEscape()
 }

package/src/project-create-workflow.ts

@@ -0,0 +1,139 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect'
+
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js'
+import { extractErrorMessage } from './error-response.js'
+import { appErrorOf, unreachedCode } from './request-outcome.js'
+
+// Loaded only through `await import(...)`, like the team create workflow:
+// the project create that setup and `orizu projects create` send.
+
+/** Sends one request; calls `onRequestStart` just before anything goes out. */
+export type ProjectCreateRequest = (path: string, init: RequestInit, onRequestStart?: () => void) => Promise<Response>
+
+const CreateReply = Schema.Struct({
+  project: Schema.Struct({
+    id: Schema.NonEmptyString,
+    name: Schema.String,
+    slug: Schema.NonEmptyString,
+    teamSlug: Schema.NonEmptyString,
+    teamId: Schema.optional(Schema.String),
+    teamName: Schema.optional(Schema.String),
+    role: Schema.optional(Schema.String),
+  }),
+})
+
+export interface CreatedProject {
+  id: string
+  name: string
+  slug: string
+  teamId: string
+  teamName: string
+  teamSlug: string
+  role: string
+}
+
+/**
+ * Runs one request under the time limit. `run` gets the signal to pass on and
+ * the hook that marks the request as sent; the body is read inside `run`, so a
+ * reply that stalls part way is under the limit too.
+ */
+function withDeadline<A, E>(
+  timeoutMs: number,
+  run: (signal: AbortSignal, markSent: () => void) => Promise<A>,
+  onFailure: (cause: unknown, outcome: { timedOut: boolean, sent: boolean }) => E,
+): Effect.Effect<A, E> {
+  return Effect.suspend(() => {
+    let sent = false
+    let timedOut = false
+    return Effect.tryPromise({
+      try: async signal => {
+        const controller = new AbortController()
+        const abort = () => controller.abort()
+        const timer = setTimeout(() => { timedOut = true; controller.abort() }, timeoutMs)
+        if (signal.aborted) abort()
+        else signal.addEventListener('abort', abort, { once: true })
+        try {
+          return await run(controller.signal, () => { sent = true })
+        } finally {
+          clearTimeout(timer)
+          signal.removeEventListener('abort', abort)
+          controller.abort()
+        }
+      },
+      catch: cause => onFailure(cause, { timedOut, sent }),
+    })
+  })
+}
+
+async function runToPromise<A>(effect: Effect.Effect<A, Error>): Promise<A> {
+  const exit = await Effect.runPromiseExit(effect)
+  if (Exit.isSuccess(exit)) return exit.value
+  throw Cause.squash(exit.cause)
+}
+
+const FAILED = 'Failed to create project'
+
+const projectMayBeCreated = (teamSlug: string, name: string) =>
+  `The project may already be created: run \`orizu projects list --team ${teamSlug}\` and look for "${name}" before creating it again.`
+
+class ProjectCreateFailure extends Error {
+  readonly _tag = 'ProjectCreateFailure'
+  constructor(message: string, readonly mayBeCreated: boolean) { super(message) }
+}
+
+/**
+ * `orizu projects create` and setup's project create: one request with a time
+ * limit, never retried, since a retry after an unclear outcome could make a
+ * second project. When the outcome is unclear, the error says how to check.
+ */
+export async function createProjectWithDeadline(teamSlug: string, name: string, request: ProjectCreateRequest): Promise<CreatedProject> {
+  const create = withDeadline(datasetTransferTimeoutMs(), async (signal, markSent) => {
+    const response = await request('/api/cli/projects', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ teamSlug, name }),
+      signal,
+    }, markSent)
+    if (!response.ok) {
+      const appError = await appErrorOf(response.clone())
+      const detail = await extractErrorMessage(response)
+      // A 5xx that is not the app's own error may come from a gateway that gave up while the app kept working.
+      if (response.status < 400 || (response.status >= 500 && appError === null)) {
+        throw new ProjectCreateFailure(`Project create got no clear answer (status ${response.status}).`, true)
+      }
+      throw new ProjectCreateFailure(detail.startsWith(FAILED) ? detail : `${FAILED}: ${detail}`, false)
+    }
+    const body = await response.text()
+    let data: unknown
+    try {
+      data = JSON.parse(body)
+    } catch {
+      data = undefined
+    }
+    const decoded = Schema.decodeUnknownResult(CreateReply)(data)
+    if (Result.isFailure(decoded)) {
+      throw new ProjectCreateFailure(`Project create returned an unexpected response (status ${response.status}).`, true)
+    }
+    const project = decoded.success.project
+    return {
+      id: project.id,
+      name: project.name,
+      slug: project.slug,
+      teamId: project.teamId || '',
+      teamName: project.teamName || project.teamSlug,
+      teamSlug: project.teamSlug,
+      role: project.role || 'admin',
+    }
+  }, (cause, { timedOut, sent }) => {
+    if (cause instanceof ProjectCreateFailure) return cause
+    if (timedOut) return new ProjectCreateFailure('Project create exceeded its deadline.', sent)
+    const unreached = unreachedCode(cause)
+    if (unreached) return new ProjectCreateFailure(`${FAILED}: could not reach the server (${unreached}).`, false)
+    const message = cause instanceof Error ? cause.message : String(cause)
+    if (!sent || message.startsWith('ORIZU_AUTH_CONTEXT_CHANGED:')) return new ProjectCreateFailure(message, false)
+    return new ProjectCreateFailure(`Project create did not finish: ${message}`, true)
+  })
+  return await runToPromise(create.pipe(
+    Effect.mapError(failure => new Error(failure.mayBeCreated ? `${failure.message}\n${projectMayBeCreated(teamSlug, name)}` : failure.message)),
+  ))
+}