experimental-a2 0.18.1 → 0.20.0

package/src/ai-pi.ts

@@ -14,6 +14,7 @@ import type {
   AssistantMessage,
   AssistantMessageEvent,
   AssistantMessageEventStream,
+  ImageContent,
   JsonObject,
   TextContent,
   ThinkingContent,
@@ -50,6 +51,8 @@ import {
   gatewayCredential,
   type Harness,
   type HarnessGeneration,
+  harnessImages,
+  type HarnessInput,
   type HarnessRead,
   type HarnessSandbox,
   type HarnessStep,
@@ -130,11 +133,14 @@ type PiRecord =
   | { call: 'step'; response: StoredResponse }
   | { call: 'compaction'; response: AssistantMessage }
 
+/** A user message as Pi takes it. */
+type PiInput = { text: string; images: ImageContent[] }
+
 type RecordedCall = {
   kind: 'step' | 'compaction'
   response: AssistantMessage
   /** Steering to queue while serving this call. */
-  steers: string[]
+  steers: PiInput[]
 }
 
 type Saved = {
@@ -232,7 +238,8 @@ async function runStep(
         fail(state, diverged(`call ${state.next} is not a ${kind}`))
       state.next++
       // Steering queued while a response streams enters after its tools.
-      for (const text of recorded.steers) await session!.steer(text)
+      for (const { text, images } of recorded.steers)
+        await session!.steer(text, images.length === 0 ? undefined : images)
       replay(out, recorded.response)
       return
     }
@@ -252,6 +259,9 @@ async function runStep(
     const upstream = realStream(model, context, {
       ...options,
       headers: { ...options?.headers, ...gatewayHeaders(credential) },
+      ...(step.speed === 'fast'
+        ? { onPayload: fastTier(options?.onPayload) }
+        : {}),
     })
     const live = kind === 'step' ? liveStep() : undefined
     for await (const event of upstream) {
@@ -547,9 +557,10 @@ async function runStep(
     }
     for (const plan of read.turns) {
       if (step.signal.aborted) return
+      const prompt = await piInput({ input: plan.prompt, signal: step.signal })
       const state: TurnState = {
         plan,
-        calls: recordedTurn(plan),
+        calls: await recordedTurn({ turn: plan, signal: step.signal }),
         next: 0,
         liveStep: false,
         over: false,
@@ -557,8 +568,9 @@ async function runStep(
         compactions: [],
       }
       turn = state
-      const running = session.prompt(plan.prompt, {
+      const running = session.prompt(prompt.text, {
         expandPromptTemplates: false,
+        ...(prompt.images.length === 0 ? {} : { images: prompt.images }),
       })
       if (plan.end !== 'live') {
         await running.catch((error: unknown) => {
@@ -622,17 +634,43 @@ async function runStep(
 // ------------------------------------------------------------ the plan
 
 /** A turn's recorded model calls, in the order Pi made them. */
-function recordedTurn(turn: HarnessTurn): RecordedCall[] {
+async function recordedTurn({
+  turn,
+  signal,
+}: {
+  turn: HarnessTurn
+  signal: AbortSignal
+}): Promise<RecordedCall[]> {
   const calls: RecordedCall[] = []
-  turn.generations.forEach((generation, index) => {
+  for (const [index, generation] of turn.generations.entries()) {
     calls.push(...recordedCalls(generation))
     const steers = turn.steers.get(index)
     const last = calls.findLast((call) => call.kind === 'step')
-    if (steers !== undefined && last !== undefined) last.steers.push(...steers)
-  })
+    if (steers !== undefined && last !== undefined)
+      for (const input of steers)
+        last.steers.push(await piInput({ input, signal }))
+  }
   return calls
 }
 
+async function piInput({
+  input,
+  signal,
+}: {
+  input: HarnessInput
+  signal: AbortSignal
+}): Promise<PiInput> {
+  const images = await harnessImages({ harness: 'pi()', input, signal })
+  return {
+    text: input.text,
+    images: images.map((image) => ({
+      type: 'image',
+      data: image.data,
+      mimeType: image.mediaType,
+    })),
+  }
+}
+
 function recordedCalls(generation: RecordedGeneration): RecordedCall[] {
   const texts = new Map<string, string>()
   const inputs = new Map<string, unknown>()
@@ -937,30 +975,28 @@ async function sessionTools(
   ) => Promise<AgentToolResult<unknown>>,
 ): Promise<ToolDefinition[]> {
   return Promise.all(
-    Object.entries(tools)
-      .filter(([, tool]) => tool.type !== 'provider')
-      .map(async ([name, tool]): Promise<ToolDefinition> => {
-        const builtin = builtinOf(tools, name)
-        if (builtin !== undefined)
-          // Pi's own definition, for its prompt; A2 already ran the call.
-          return Object.assign(builtinDefinition(modules, builtin, cwd), {
-            execute: (
-              toolCallId: string,
-              _params: unknown,
-              signal?: AbortSignal,
-            ) => result(toolCallId, signal, 'pi'),
-          })
-        return {
-          name,
-          label: name,
-          description:
-            typeof tool.description === 'string' ? tool.description : '',
-          parameters: (await asSchema(tool.inputSchema)
-            .jsonSchema) as ToolDefinition['parameters'],
-          execute: (toolCallId, _params, signal) =>
-            result(toolCallId, signal, 'tool'),
-        }
-      }),
+    Object.entries(tools).map(async ([name, tool]): Promise<ToolDefinition> => {
+      const builtin = builtinOf(tools, name)
+      if (builtin !== undefined)
+        // Pi's own definition, for its prompt; A2 already ran the call.
+        return Object.assign(builtinDefinition(modules, builtin, cwd), {
+          execute: (
+            toolCallId: string,
+            _params: unknown,
+            signal?: AbortSignal,
+          ) => result(toolCallId, signal, 'pi'),
+        })
+      return {
+        name,
+        label: name,
+        description:
+          typeof tool.description === 'string' ? tool.description : '',
+        parameters: (await asSchema(tool.inputSchema)
+          .jsonSchema) as ToolDefinition['parameters'],
+        execute: (toolCallId, _params, signal) =>
+          result(toolCallId, signal, 'tool'),
+      }
+    }),
   )
 }
 
@@ -1227,6 +1263,26 @@ function thinkingLevel(step: HarnessStep): {
   return { thinkingLevel: step.reasoning === 'none' ? 'off' : step.reasoning }
 }
 
+type PayloadHook = NonNullable<
+  NonNullable<Parameters<ModelRuntime['streamSimple']>[2]>['onPayload']
+>
+
+/** Asks AI Gateway for the model's fast tier, on the payload Pi's own hook returns. */
+function fastTier(inner: PayloadHook | undefined): PayloadHook {
+  return async (payload, model) => {
+    const body = ((await inner?.(payload, model)) ?? payload) as {
+      providerOptions?: { gateway?: object }
+    }
+    return {
+      ...body,
+      providerOptions: {
+        ...body.providerOptions,
+        gateway: { ...body.providerOptions?.gateway, speed: 'fast' },
+      },
+    }
+  }
+}
+
 function gatewayHeaders(credential: {
   token: string
   method: string

package/src/ai-stored-state.ts

@@ -211,9 +211,7 @@ const storeState = <S extends AIStoredView>(state: S): AIStoredState => {
     if (
       value === undefined ||
       (typeof value === 'string' && value.length > 80) ||
-      (field !== undefined &&
-        payloadFields.has(field) &&
-        !(field === 'input' && isRecord(value) && 'message' in value)) ||
+      (field !== undefined && payloadFields.has(field)) ||
       (isRecord(value) && Object.hasOwn(value, '$a2Value'))
     )
       return intern(value)

package/src/ai.ts

@@ -23,7 +23,8 @@ import {
 } from './ai-client-state.ts'
 export type { PendingQueueCommand } from './ai-client-state.ts'
 import { applyControlChanges } from './ai-control-state.ts'
-import { initialControlState } from './ai-control.ts'
+import { STEERED_REASON, unexplainedAdmission } from './ai-control.ts'
+import { isJSONCompatible, isRecord, isUIMessage } from './ai-message-shape.ts'
 import { AI_EVENT_ID_PREFIX } from './ai-id.ts'
 import type {
   ControlCommit,
@@ -31,6 +32,7 @@ import type {
   ControlCommand,
   ControlReceipt,
   InboxItem,
+  InputRef,
   ToolExecutionRequest,
   WorkReport,
 } from './ai-control.ts'
@@ -39,6 +41,7 @@ export type {
   ControlCommand,
   ControlReceipt,
   InboxItem,
+  InputRef,
 } from './ai-control.ts'
 import { contract as createContract } from './contract.ts'
 import type { Contract, ContractEvent, EventDefs } from './contract.ts'
@@ -139,10 +142,15 @@ export type TranscriptMessage<M extends UIMessage> = Omit<M, 'parts'> & {
 
 export type SessionCreatedPayload = { metadata?: JSONValue }
 export type SessionClosedPayload = { reason?: string }
-export type MessageCreatedPayload<M extends UIMessage> = {
-  message: M
-  /** For user messages, false records passive context. Omission or true schedules. */
-  generate?: boolean
+/**
+ * A message entering the transcript. Its content is the command's that brought
+ * it in, which every reader of the transcript has already folded.
+ */
+export type MessageCreatedPayload = {
+  messageId: string
+  role: UIMessage['role']
+  /** For user messages, false records passive context. Omission schedules. */
+  generate?: false
 }
 export type MessageCompletedPayload = { messageId: string }
 type MessageInterruption = {
@@ -312,7 +320,7 @@ export type AIEventDefs<M extends UIMessage = UIMessage> = {
   }>
   'ai.session.created': StandardSchemaV1<SessionCreatedPayload>
   'ai.session.closed': StandardSchemaV1<SessionClosedPayload>
-  'ai.message.created': StandardSchemaV1<MessageCreatedPayload<M>>
+  'ai.message.created': StandardSchemaV1<MessageCreatedPayload>
   'ai.message.completed': StandardSchemaV1<MessageCompletedPayload>
   'ai.message.interrupted': StandardSchemaV1<MessageInterruptedPayload>
   'ai.generation.requested': StandardSchemaV1<GenerationRequestedPayload>
@@ -402,7 +410,7 @@ export type GenerationUsage = {
 export type AIState<M extends UIMessage = UIMessage> = {
   inbox: { paused: boolean; items: InboxItem<M>[] }
   pendingQueueCommands?: PendingQueueCommand<M>[]
-  active: ActiveTurn<M> | null
+  active: ActiveTurn | null
   starting: boolean
   receipt: ControlReceipt | null
   pausedGenerationIds?: Record<string, true>
@@ -433,13 +441,13 @@ export type AIState<M extends UIMessage = UIMessage> = {
   error: string | null
 }
 
-/** The `UIMessage` type a contract's `ai.message.created` schema carries. */
+/** The `UIMessage` type a contract's input commands carry. */
 export type AIMessageOf<D> = D extends {
-  readonly 'ai.message.created': infer S extends StandardSchemaV1
+  readonly 'ai.control.requested': infer S extends StandardSchemaV1
 }
-  ? StandardSchemaV1.InferOutput<S> extends MessageCreatedPayload<
-      infer M extends UIMessage
-    >
+  ? Extract<StandardSchemaV1.InferOutput<S>, { action: 'send' }> extends {
+      message: infer M extends UIMessage
+    }
     ? M
     : UIMessage
   : UIMessage
@@ -529,33 +537,6 @@ const schema = <T>(
   },
 })
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value)
-
-const isJSONCompatible = (
-  value: unknown,
-  seen: Set<object> = new Set(),
-): boolean => {
-  if (
-    value === null ||
-    typeof value === 'string' ||
-    typeof value === 'boolean'
-  ) {
-    return true
-  }
-  if (typeof value === 'number') return Number.isFinite(value)
-  if (typeof value === 'undefined') return true
-  if (typeof value !== 'object') return false
-  if (seen.has(value)) return false
-  seen.add(value)
-  const valid = Array.isArray(value)
-    ? value.every((item) => isJSONCompatible(item, seen))
-    : Object.getPrototypeOf(value) === Object.prototype &&
-      Object.values(value).every((item) => isJSONCompatible(item, seen))
-  seen.delete(value)
-  return valid
-}
-
 const jsonObject = <T extends object>(
   label: string,
   check: (value: Record<string, unknown>) => boolean,
@@ -584,45 +565,39 @@ const optionalStringField = (
   key: string,
 ): boolean => value[key] === undefined || typeof value[key] === 'string'
 
-const messageValue = (value: unknown): value is UIMessage =>
-  isRecord(value) &&
-  typeof value['id'] === 'string' &&
-  (value['role'] === 'user' ||
-    value['role'] === 'assistant' ||
-    value['role'] === 'system') &&
-  Array.isArray(value['parts']) &&
-  value['parts'].every(
-    (part) => isRecord(part) && typeof part['type'] === 'string',
-  ) &&
-  isJSONCompatible(value)
-
 const validateMessage = <M extends UIMessage>(
   value: unknown,
   messageSchema?: StandardSchemaV1<M>,
 ): SchemaResult<M> => {
-  if (!messageValue(value)) return issue('invalid AI SDK UIMessage')
+  if (!isUIMessage(value)) return issue('invalid AI SDK UIMessage')
   if (!messageSchema) return { value: value as M }
   return validateSync(messageSchema, value, 'the AI message')
 }
 
-const messagePayloadSchema = <M extends UIMessage>(
-  messageSchema?: StandardSchemaV1<M>,
-): StandardSchemaV1<MessageCreatedPayload<M>> =>
-  schema('ai.message.created', (value) => {
-    if (!isRecord(value)) return issue('invalid ai.message.created payload')
-    const message = validateMessage(value['message'], messageSchema)
-    if (message.issues) return { issues: message.issues }
-    const generate = value['generate']
-    if (generate !== undefined && typeof generate !== 'boolean') {
-      return issue('invalid ai.message.created generate flag')
-    }
+const messageCreatedSchema: StandardSchemaV1<MessageCreatedPayload> = schema(
+  'ai.message.created',
+  (value) => {
+    if (
+      !isRecord(value) ||
+      Object.keys(value).some(
+        (key) => key !== 'messageId' && key !== 'role' && key !== 'generate',
+      ) ||
+      !stringField(value, 'messageId') ||
+      (value['role'] !== 'user' &&
+        value['role'] !== 'assistant' &&
+        value['role'] !== 'system') ||
+      (value['generate'] !== undefined && value['generate'] !== false)
+    )
+      return issue('invalid ai.message.created payload')
     return {
       value: {
-        message: message.value,
-        ...(generate === false ? { generate: false } : {}),
+        messageId: value['messageId'] as string,
+        role: value['role'],
+        ...(value['generate'] === false ? { generate: false as const } : {}),
       },
     }
-  })
+  },
+)
 
 const progressPayloadSchema: StandardSchemaV1<GenerationProgressPayload> =
   schema('ai.generation.progress', (value) => {
@@ -731,6 +706,14 @@ export function createEvents<M extends UIMessage = UIMessage>(options?: {
           'AI command',
         )
         if (payload.issues) return { issues: payload.issues }
+        if (
+          action === 'interrupt' &&
+          isRecord(payload.value) &&
+          payload.value['reason'] === STEERED_REASON
+        )
+          return issue(
+            `the interruption reason "${STEERED_REASON}" is reserved for steering`,
+          )
         return { value: { action, [key]: payload.value } as ControlCommand<M> }
       }
       if (action === 'send' || action === 'edit' || action === 'steer') {
@@ -857,7 +840,7 @@ export function createEvents<M extends UIMessage = UIMessage>(options?: {
     'ai.session.closed': jsonObject('ai.session.closed', (value) =>
       optionalStringField(value, 'reason'),
     ),
-    'ai.message.created': messagePayloadSchema(messageSchema),
+    'ai.message.created': messageCreatedSchema,
     'ai.message.completed': jsonObject('ai.message.completed', (value) =>
       stringField(value, 'messageId'),
     ),
@@ -1036,7 +1019,7 @@ export function createEvents<M extends UIMessage = UIMessage>(options?: {
 export const events: AIEventDefs<UIMessage> = createEvents()
 
 const initialState = <M extends UIMessage>(): AIState<M> => ({
-  inbox: initialControlState<M>().inbox,
+  inbox: { paused: false, items: [] },
   pendingQueueCommands: [],
   active: null,
   starting: false,
@@ -1153,6 +1136,22 @@ export function reduceAIState<M extends UIMessage>(
   )
 }
 
+/**
+ * An input's content, while it is queued or about to enter the transcript:
+ * its inbox item's, or its pending send's or steer's, whose command id is the
+ * input's id.
+ */
+function inputContent<M extends UIMessage>(state: AIState<M>, id: string): M {
+  const queued = state.inbox.items.find((item) => item.id === id)?.message
+  if (queued !== undefined) return queued
+  const command = state.pendingQueueCommands?.find(
+    (item) => item.commandId === id,
+  )?.command
+  if (command?.action === 'send' || command?.action === 'steer')
+    return command.message
+  throw unexplainedAdmission(id)
+}
+
 function reduceAIEvent<M extends UIMessage>(
   state: AIState<M>,
   event: { type: string; payload: unknown; index: number; id?: string },
@@ -1177,12 +1176,35 @@ function reduceAIEvent<M extends UIMessage>(
     }
     case 'ai.control.committed': {
       const commit = event.payload as ControlCommit
-      const visible = applyControlChanges({
-        state: { inbox: state.inbox, active: state.active },
-        changes: commit.changes.filter(
-          (change) => change.path[0] === 'inbox' || change.path[0] === 'active',
-        ),
-      })
+      const changes = commit.changes.filter(
+        (change) => change.path[0] === 'inbox' || change.path[0] === 'active',
+      )
+      let { inbox, active } = state
+      if (changes.length > 0) {
+        // A commit holds inputs by reference; their content is the commands'.
+        const visible = applyControlChanges({
+          state: {
+            inbox: {
+              ...inbox,
+              items: inbox.items.map(
+                ({ message: _, ...input }): InputRef => input,
+              ),
+            },
+            active,
+          },
+          changes,
+        })
+        const queued = new Map(inbox.items.map((item) => [item.id, item]))
+        inbox = {
+          ...visible.inbox,
+          items: visible.inbox.items.map((input) => ({
+            ...input,
+            message:
+              queued.get(input.id)?.message ?? inputContent(state, input.id),
+          })),
+        }
+        active = visible.active
+      }
       const { phase } = commit.view
       const status: AgentStatus = commit.view.closed
         ? 'closed'
@@ -1199,7 +1221,8 @@ function reduceAIEvent<M extends UIMessage>(
                 : 'idle'
       return {
         ...state,
-        ...visible,
+        inbox,
+        active,
         status,
         activeRequestId: commit.view.requestId,
         activeRequestReason: commit.view.requestReason,
@@ -1214,9 +1237,24 @@ function reduceAIEvent<M extends UIMessage>(
       const settled = pending.find(
         (item) => item.commandId === receipt.commandId,
       )
+      // An edit's content takes effect at its receipt.
+      const edited =
+        receipt.outcome === 'applied' && settled?.command.action === 'edit'
+          ? settled.command.message
+          : undefined
       return {
         ...state,
         receipt,
+        ...(edited === undefined
+          ? {}
+          : {
+              inbox: {
+                ...state.inbox,
+                items: state.inbox.items.map((item) =>
+                  item.id === edited.id ? { ...item, message: edited } : item,
+                ),
+              },
+            }),
         ...(settled === undefined
           ? {}
           : {
@@ -1329,7 +1367,8 @@ function reduceAIEvent<M extends UIMessage>(
         activeProjection: null,
       }
     case 'ai.message.created': {
-      const { message } = event.payload as MessageCreatedPayload<M>
+      const { messageId } = event.payload as MessageCreatedPayload
+      const message = inputContent(state, messageId)
       return {
         ...state,
         messages: upsertMessage(state.messages, message),
@@ -2516,7 +2555,7 @@ export function handlerContext<D extends AgentToolEventDefs = AIEventDefs>(
 }
 
 /** The built-in AI reducer's name, and so its checkpoint identity. */
-export const AI_STATE_REDUCER = 'a2.ai.state.v26'
+export const AI_STATE_REDUCER = 'a2.ai.state.v27'
 
 /**
  * The built-in AI protocol plus application events, as a core contract whose

package/src/errors.ts

@@ -7,7 +7,7 @@ export type A2ServerErrorCode =
   | 'SESSION_CLEARED' // a read or call reached across the session's latest clear
   | 'CLAIM_EXPIRED' // ctx.signal abort reason: the attempt's lease lapsed without renewal
   | 'STORE_UNAVAILABLE' // store backend failure — retryable, nothing was written
-  | 'STORE_NOT_CONFIGURED' // production boot with no `store` passed
+  | 'STORE_NOT_CONFIGURED' // no `store` in production, a missing peer dependency, or Postgres lacks A2's tables
   | 'UNKNOWN_PRESENCE_FIELD' // presence field not in the contract's `presence` map
   | 'PRESENCE_NOT_SUPPORTED' // contract declares presence but the store lacks the capability
 

package/src/internal.ts

@@ -7,7 +7,8 @@ import type { ScheduledEvent } from './scheduler-task.ts'
 import type { DrainableServer } from './server.ts'
 import type { Event } from './store.ts'
 
-export type DrainOutcome = 'busy' | 'stalled' | 'settled'
+/** `failed`: a scheduler drain threw after arming its successor. */
+export type DrainOutcome = 'busy' | 'stalled' | 'settled' | 'failed'
 
 /**
  * A null-prototype record for maps keyed by caller-controlled strings

package/src/libfx.d.ts

@@ -14,8 +14,15 @@ declare module 'libfx' {
     cancel(): void
   }
 
+  export type FxPromptBlock =
+    | { type: 'text'; text: string }
+    | { type: 'image'; data: string; mimeType: string }
+
   export type FxAgent = {
-    prompt(input: string, options?: { signal?: AbortSignal }): FxTurn
+    prompt(
+      input: string | FxPromptBlock[],
+      options?: { signal?: AbortSignal },
+    ): FxTurn
     checkpoint(): Promise<Uint8Array>
     close(): Promise<void>
   }

package/src/postgres-notifications.ts

@@ -220,25 +220,3 @@ export function postgresNotifications(
   }
   return manager
 }
-
-export const POSTGRES_NOTIFICATIONS_SQL = `
-create or replace function a2_notify_events() returns trigger language plpgsql as $$
-begin
-  perform pg_notify('a2_events_' || md5(new.session_id), '');
-  return null;
-end $$;
-create or replace function a2_notify_presence() returns trigger language plpgsql as $$
-begin
-  perform pg_notify('a2_presence_' || md5(case when TG_OP = 'DELETE' then old.ns else new.ns end),
-    coalesce(current_setting('a2.presence_source', true), ''));
-  return null;
-end $$;
-do $$ begin
-  if not exists (select 1 from pg_trigger where tgname = 'a2_notify_events' and tgrelid = 'a2_events'::regclass) then
-    create trigger a2_notify_events after insert on a2_events for each row execute function a2_notify_events();
-  end if;
-  if not exists (select 1 from pg_trigger where tgname = 'a2_notify_presence' and tgrelid = 'a2_presence'::regclass) then
-    create trigger a2_notify_presence after insert or update or delete on a2_presence for each row execute function a2_notify_presence();
-  end if;
-end $$;
-`

package/src/postgres-resources.ts

@@ -15,10 +15,7 @@ export type PostgresQueries = {
   client: PostgresClient
   raw: PostgresClient
   exclusive<T>(fn: () => Promise<T>): Promise<T>
-  initialize(options: {
-    schema: string
-    run: () => Promise<void>
-  }): Promise<void>
+  initialize(options: { key: string; run: () => Promise<void> }): Promise<void>
   close(): Promise<void>
 }
 
@@ -128,7 +125,7 @@ export function postgresConnectionKey({
 
 const queries = (raw: PostgresClient): PostgresQueries => {
   let pending: Promise<unknown> = Promise.resolve()
-  const schemas = new Map<string, Promise<void>>()
+  const initialized = new Map<string, Promise<void>>()
   const exclusive = <T>(fn: () => Promise<T>): Promise<T> => {
     const result = pending.then(fn)
     pending = result.catch(() => {})
@@ -140,13 +137,13 @@ const queries = (raw: PostgresClient): PostgresQueries => {
       ? raw
       : { query: (text, values) => exclusive(() => raw.query(text, values)) },
     exclusive,
-    initialize({ schema, run }) {
-      const existing = schemas.get(schema)
+    initialize({ key, run }) {
+      const existing = initialized.get(key)
       if (existing) return existing
       const attempt = run()
-      schemas.set(schema, attempt)
+      initialized.set(key, attempt)
       void attempt.catch(() => {
-        if (schemas.get(schema) === attempt) schemas.delete(schema)
+        if (initialized.get(key) === attempt) initialized.delete(key)
       })
       return attempt
     },