dsh-lcx-codex 0.3.3 → 0.4.0-rc.13

package/lib/dsh-pi-responses.js

@@ -1,339 +0,0 @@
-import { convertResponsesMessages } from '@earendil-works/pi-ai/api/openai-responses-shared'
-import { offloadRequestImages } from '@deepseek-ai/dsh-llm'
-
-export const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20 * 1024 * 1024
-const SUPPORTED_IMAGE_MEDIA_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp', 'image/gif'])
-const RESPONSES_TOOL_CALL_PROVIDERS = new Set(['openai', 'openai-codex', 'opencode'])
-
-function compactError(message, code, cause) {
-  const error = new Error(message, cause === undefined ? undefined : { cause })
-  error.code = code
-  return error
-}
-
-function invalidReplay(message) {
-  return compactError(`invalid pi-ai replay state: ${message}`, 'LCX_COMPACT_INVALID_REPLAY_STATE')
-}
-
-function unsupportedContent(type) {
-  return compactError(
-    `LCX Compact cannot safely serialize DSH message content type: ${String(type)}`,
-    'LCX_CHECKPOINT_PORTABLE_UNSUPPORTED_CONTENT',
-  )
-}
-
-function parseArguments(raw) {
-  try {
-    const parsed = JSON.parse(raw)
-    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
-  } catch {
-    // Match the DSH pi-ai adapter: malformed model arguments replay as an empty object.
-  }
-  return {}
-}
-
-function emptyUsage() {
-  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }
-}
-
-function replayBlockType(type) {
-  if (type === 'text') return 'text'
-  if (type === 'reasoning') return 'reasoning'
-  if (type === 'tool-call') return 'tool-call'
-  return undefined
-}
-
-export function readDshPiReplayState(value) {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) throw invalidReplay('expected a replay envelope')
-  const response = value.response
-  if (response === null || typeof response !== 'object' || Array.isArray(response)) throw invalidReplay('expected a response object')
-  if (response.kind !== 'pi-ai') throw invalidReplay('unknown state kind')
-  if (response.version !== 2) throw invalidReplay(`unsupported version ${String(response.version)}`)
-  for (const key of ['api', 'provider', 'model']) {
-    if (typeof response[key] !== 'string' || response[key].length === 0) throw invalidReplay(`${key} must be a non-empty string`)
-  }
-  if (!['stop', 'length', 'toolUse', 'error', 'aborted'].includes(response.stopReason)) throw invalidReplay('unknown stopReason')
-  if (response.responseModel !== undefined && typeof response.responseModel !== 'string') throw invalidReplay('responseModel must be a string')
-  if (response.responseId !== undefined && typeof response.responseId !== 'string') throw invalidReplay('responseId must be a string')
-  if (!Array.isArray(value.blocks)) throw invalidReplay('blocks must be an array')
-  for (const [index, block] of value.blocks.entries()) {
-    if (block === null || typeof block !== 'object' || Array.isArray(block)) throw invalidReplay(`block ${index} must be an object`)
-    if (!['text', 'reasoning', 'tool-call'].includes(block.type)) throw invalidReplay(`block ${index} has an unknown type`)
-    for (const signature of ['textSignature', 'thinkingSignature', 'thoughtSignature']) {
-      if (block[signature] !== undefined && typeof block[signature] !== 'string') {
-        throw invalidReplay(`block ${index} ${signature} must be a string`)
-      }
-    }
-    if (block.redacted !== undefined && typeof block.redacted !== 'boolean') throw invalidReplay(`block ${index} redacted must be boolean`)
-  }
-  return { response, blocks: value.blocks }
-}
-
-function foreignAssistant(message) {
-  const source = message?.source?.kind === 'model' ? message.source : undefined
-  const content = []
-  for (const block of message.content ?? []) {
-    if (block?.type === 'text') content.push({ type: 'text', text: block.text })
-    else if (block?.type === 'reasoning') content.push({ type: 'thinking', thinking: block.text })
-    else if (block?.type === 'tool-call') {
-      content.push({ type: 'toolCall', id: String(block.id), name: String(block.name), arguments: parseArguments(block.arguments) })
-    } else if (block?.type === 'image') {
-      throw unsupportedContent('assistant image')
-    } else {
-      throw unsupportedContent(block?.type)
-    }
-  }
-  return {
-    role: 'assistant',
-    content,
-    api: 'dsh-foreign',
-    provider: source?.provider ?? 'dsh-foreign',
-    model: source?.model ?? 'dsh-foreign',
-    usage: emptyUsage(),
-    stopReason: content.some((block) => block.type === 'toolCall') ? 'toolUse' : 'stop',
-    timestamp: 0,
-  }
-}
-
-function replayedAssistant(message, source) {
-  const state = readDshPiReplayState(source.replayState)
-  if (state.response.provider !== source.provider) throw invalidReplay('provider does not match assistant source')
-  if (state.response.model !== source.model) throw invalidReplay('model does not match assistant source')
-  if (state.blocks.length !== message.content.length) throw invalidReplay('block count does not match assistant content')
-  const content = message.content.map((block, index) => {
-    const replay = state.blocks[index]
-    if (replayBlockType(block?.type) !== replay?.type) throw invalidReplay(`block ${index} does not match assistant content`)
-    if (block.type === 'text') {
-      return { type: 'text', text: block.text, ...(replay.textSignature === undefined ? {} : { textSignature: replay.textSignature }) }
-    }
-    if (block.type === 'reasoning') {
-      return {
-        type: 'thinking',
-        thinking: block.text,
-        ...(replay.thinkingSignature === undefined ? {} : { thinkingSignature: replay.thinkingSignature }),
-        ...(replay.redacted === undefined ? {} : { redacted: replay.redacted }),
-      }
-    }
-    return {
-      type: 'toolCall',
-      id: String(block.id),
-      name: String(block.name),
-      arguments: parseArguments(block.arguments),
-      ...(replay.thoughtSignature === undefined ? {} : { thoughtSignature: replay.thoughtSignature }),
-    }
-  })
-  return {
-    role: 'assistant',
-    content,
-    api: state.response.api,
-    provider: state.response.provider,
-    model: state.response.model,
-    ...(state.response.responseModel === undefined ? {} : { responseModel: state.response.responseModel }),
-    ...(state.response.responseId === undefined ? {} : { responseId: state.response.responseId }),
-    usage: emptyUsage(),
-    stopReason: state.response.stopReason,
-    timestamp: 0,
-  }
-}
-
-function toPiAssistant(message, onReplayDegrade) {
-  const source = message?.source
-  if (source?.kind !== 'model' || source.replayState === undefined) return foreignAssistant(message)
-  try {
-    return replayedAssistant(message, source)
-  } catch (error) {
-    if (error?.code !== 'LCX_COMPACT_INVALID_REPLAY_STATE') throw error
-    onReplayDegrade?.(error.message)
-    return foreignAssistant(message)
-  }
-}
-
-function hasImageBlocks(blocks) {
-  return (blocks ?? []).some((block) => block?.type === 'image' || (block?.type === 'tool-result' && hasImageBlocks(block.content)))
-}
-
-export async function resolveDshImage(block, options = {}) {
-  if (typeof options.resolveImage !== 'function') {
-    throw compactError('LCX Compact cannot resolve image attachment without the DSH attachment service', 'LCX_COMPACT_IMAGE_UNAVAILABLE')
-  }
-  let stored
-  try {
-    stored = await options.resolveImage(block, options.signal)
-  } catch (error) {
-    if (error?.code?.startsWith?.('LCX_COMPACT_IMAGE_')) throw error
-    throw compactError('LCX Compact failed to read image attachment', 'LCX_COMPACT_IMAGE_UNAVAILABLE', error)
-  }
-  const data = stored?.data
-  const mediaType = String(stored?.mediaType ?? stored?.ref?.mediaType ?? block?.attachment?.mediaType ?? '').toLowerCase()
-  const bytes = data?.byteLength ?? data?.length
-  if (!SUPPORTED_IMAGE_MEDIA_TYPES.has(mediaType)) {
-    throw compactError(`LCX Compact does not support image media type: ${mediaType || 'missing'}`, 'LCX_COMPACT_IMAGE_UNSUPPORTED')
-  }
-  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
-    throw compactError('LCX Compact received empty or invalid image attachment data', 'LCX_COMPACT_IMAGE_UNAVAILABLE')
-  }
-  const base64 = Buffer.from(data).toString('base64')
-  const maxBytes = options.maxRequestImageBytes ?? DEFAULT_MAX_REQUEST_IMAGE_BYTES
-  if (base64.length > maxBytes) {
-    throw compactError(`LCX Compact image attachment exceeds the ${maxBytes}-byte base64 payload limit`, 'LCX_COMPACT_IMAGE_TOO_LARGE')
-  }
-  const imageUrl = `data:${mediaType};base64,${base64}`
-  options.onImageResolved?.({ imageUrl, attachment: structuredClone(stored?.ref ?? block.attachment) })
-  return { type: 'image', data: base64, mimeType: mediaType }
-}
-
-async function piUserContent(blocks, options) {
-  const content = []
-  for (const block of blocks ?? []) {
-    if (block?.type === 'text') {
-      if (block.text.length > 0) content.push({ type: 'text', text: block.text })
-    } else if (block?.type === 'reasoning') {
-      continue
-    } else if (block?.type === 'image') {
-      if (options.imageSupport === 'unsupported') {
-        content.push({ type: 'image', data: '', mimeType: block?.attachment?.mediaType ?? 'image/png' })
-      } else {
-        content.push(await resolveDshImage(block, options))
-      }
-    } else if (block?.type === 'tool-result') {
-      const nested = await piUserContent(block.content, options)
-      if (typeof nested === 'string') {
-        if (nested.length > 0) content.push({ type: 'text', text: nested })
-      } else {
-        content.push(...nested)
-      }
-    } else {
-      throw unsupportedContent(block?.type)
-    }
-  }
-  if (content.every((block) => block.type === 'text')) return content.map((block) => block.text).join('')
-  return content
-}
-
-async function dshToPiContext(messages, options) {
-  const converted = []
-  const toolNames = new Map()
-  for (const message of messages ?? []) {
-    if (message === null || typeof message !== 'object' || Array.isArray(message) || !Array.isArray(message.content)) {
-      throw unsupportedContent('message')
-    }
-    if (message.role === 'system') {
-      if (hasImageBlocks(message.content)) throw unsupportedContent('system image')
-      const text = message.content.filter((block) => block?.type === 'text').map((block) => block.text).join('')
-      if (message.content.some((block) => block?.type !== 'text' && block?.type !== 'reasoning')) throw unsupportedContent('system block')
-      if (text) converted.push({ role: 'user', content: text, timestamp: 0 })
-      continue
-    }
-    if (message.role === 'assistant') {
-      const assistant = toPiAssistant(message, options.onReplayDegrade)
-      for (const block of assistant.content) {
-        if (block.type === 'toolCall') toolNames.set(block.id, block.name)
-      }
-      converted.push(assistant)
-      continue
-    }
-    if (message.role !== 'user') throw unsupportedContent(`message role ${String(message.role)}`)
-    const ordinary = message.content.filter((block) => block?.type !== 'tool-result')
-    if (ordinary.some((block) => !['text', 'reasoning', 'image'].includes(block?.type))) throw unsupportedContent(ordinary.find((block) => !['text', 'reasoning', 'image'].includes(block?.type))?.type)
-    const content = await piUserContent(ordinary, options)
-    const results = message.content.filter((block) => block?.type === 'tool-result')
-    if ((typeof content === 'string' ? content.length > 0 : content.length > 0) || results.length === 0) {
-      converted.push({ role: 'user', content, timestamp: 0 })
-    }
-    for (const result of results) {
-      const resultContent = await piUserContent(result.content, options)
-      converted.push({
-        role: 'toolResult',
-        toolCallId: String(result.toolCallId),
-        toolName: toolNames.get(String(result.toolCallId)) ?? 'unknown',
-        content: typeof resultContent === 'string'
-          ? [{ type: 'text', text: resultContent || '(no output)' }]
-          : resultContent,
-        isError: result.isError ?? false,
-        timestamp: 0,
-      })
-    }
-  }
-  return { messages: converted }
-}
-
-export async function resolveModelImageSupport(llm, route, signal) {
-  if (typeof llm?.resolveModelInfo !== 'function') return 'unknown'
-  try {
-    const model = await llm.resolveModelInfo(route.provider, route.model, signal)
-    if (!Array.isArray(model?.inputModalities)) return 'unknown'
-    return model.inputModalities.includes('image') ? 'supported' : 'unsupported'
-  } catch {
-    return 'unknown'
-  }
-}
-
-export async function serializeDshResponsesInput(messages, options = {}) {
-  const route = options.route ?? {}
-  const imageSupport = options.imageSupport ?? 'unknown'
-  if (!['supported', 'unsupported', 'unknown'].includes(imageSupport)) {
-    throw compactError(`Invalid LCX Compact image capability: ${String(imageSupport)}`, 'LCX_COMPACT_IMAGE_CAPABILITY_UNKNOWN')
-  }
-  if (imageSupport === 'unknown' && (messages ?? []).some((message) => hasImageBlocks(message?.content))) {
-    throw compactError('LCX Compact cannot determine whether the target model accepts images', 'LCX_COMPACT_IMAGE_CAPABILITY_UNKNOWN')
-  }
-  const context = await dshToPiContext(messages, { ...options, imageSupport })
-  const model = {
-    id: String(route.model ?? ''),
-    name: String(route.model ?? ''),
-    api: 'openai-responses',
-    provider: String(route.provider ?? ''),
-    baseUrl: String(route.baseURL ?? ''),
-    input: imageSupport === 'supported' ? ['text', 'image'] : ['text'],
-    reasoning: true,
-    contextWindow: 1,
-    maxTokens: 1,
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-  }
-  const allowedToolCallProviders = new Set([...RESPONSES_TOOL_CALL_PROVIDERS, model.provider])
-  const converted = convertResponsesMessages(model, context, allowedToolCallProviders, { includeSystemPrompt: false })
-  // Pi emits user messages in the SDK shorthand `{ role, content }`. DSH's
-  // checkpoint/store contract is the explicit Responses item shape, so make
-  // that boundary canonical without changing Pi's internal serializer.
-  const stripImageDetail = (value) => {
-    if (!Array.isArray(value)) return value
-    return value.map((part) => {
-      if (part?.type === 'input_image') {
-        const { detail: _detail, ...withoutDetail } = part
-        return withoutDetail
-      }
-      return part
-    })
-  }
-  return converted.map((item) => {
-    if (item?.role === 'user') {
-      const content = typeof item.content === 'string'
-        ? [{ type: 'input_text', text: item.content }]
-        : item.content
-      return { ...(item.type === undefined ? { type: 'message' } : {}), role: 'user', content: stripImageDetail(content) }
-    }
-    if (item?.type === 'function_call_output') return { ...item, output: stripImageDetail(item.output) }
-    return item
-  })
-}
-
-function hasCompleteImageMetadata(messages) {
-  const complete = (blocks) => blocks.every((block) => {
-    if (block.type === 'image') {
-      const bytes = Number(block.attachment?.bytes)
-      return Number.isSafeInteger(bytes) && bytes > 0
-    }
-    return block.type !== 'tool-result' || complete(block.content)
-  })
-  return messages.every((message) => complete(message.content))
-}
-
-export function offloadDshRequestImages(messages, maxRequestImageBytes = DEFAULT_MAX_REQUEST_IMAGE_BYTES) {
-  if (!Number.isSafeInteger(maxRequestImageBytes) || maxRequestImageBytes <= 0) {
-    throw compactError('LCX Compact maxRequestImageBytes must be a positive integer', 'LCX_COMPACT_IMAGE_LIMIT_INVALID')
-  }
-  const input = messages ?? []
-  return hasCompleteImageMetadata(input)
-    ? offloadRequestImages(input, maxRequestImageBytes)
-    : input
-}

package/lib/private-file.js

@@ -1,18 +0,0 @@
-import { execFileSync } from 'node:child_process'
-
-export function ensurePrivateFileAcl(target) {
-  if (process.platform !== 'win32') return true
-  try {
-    const identity = execFileSync('whoami.exe', ['/user', '/fo', 'csv', '/nh'], {
-      encoding: 'utf8', timeout: 3000, windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'],
-    }).match(/S-1-[0-9-]+/iu)?.[0]
-    if (!identity) return false
-    const sids = [identity, 'S-1-5-18', 'S-1-5-32-544'].map((sid) => `*${sid}:F`)
-    execFileSync('icacls.exe', [target, '/inheritance:r', '/grant:r', ...sids], {
-      encoding: 'utf8', timeout: 5000, windowsHide: true, stdio: 'ignore',
-    })
-    return true
-  } catch {
-    return false
-  }
-}

package/lib/session-lease.js

@@ -1,70 +0,0 @@
-const STALE_SESSION_CODE = 'LCX_SESSION_GENERATION_STALE'
-
-function sessionIdOf(session) {
-  const value = session?.id
-  return typeof value === 'string' && value.length > 0 ? value : undefined
-}
-
-function staleSessionError(sessionId, phase) {
-  const error = new Error(`LCX session generation became stale during ${phase}: ${sessionId}`)
-  error.code = STALE_SESSION_CODE
-  return error
-}
-
-/**
- * Track the public DSH session lifecycle without depending on private agent-loop APIs.
- * A lease is intentionally fail-closed when a session service exists but the id is
- * unknown; callers without a session id (or without the optional service) retain
- * the pre-lifecycle behavior.
- */
-export function createSessionGenerationTracker(ctx) {
-  const sessions = ctx?.get?.('sessions') ?? ctx?.sessions
-  const enabled = Boolean(sessions && typeof ctx?.on === 'function')
-  const states = new Map()
-  const disposers = []
-
-  const created = (session) => {
-    const id = sessionIdOf(session)
-    if (!id) return
-    const previous = states.get(id)
-    states.set(id, { generation: (previous?.generation ?? 0) + 1, active: true })
-  }
-  const disposed = (session) => {
-    const id = sessionIdOf(session)
-    if (!id) return
-    const previous = states.get(id)
-    states.set(id, { generation: (previous?.generation ?? 0) + 1, active: false })
-  }
-
-  if (enabled) {
-    for (const session of sessions.list?.() ?? []) created(session)
-    for (const [event, handler] of [['session/created', created], ['session/disposed', disposed]]) {
-      const dispose = ctx.on(event, handler)
-      if (typeof dispose === 'function') disposers.push(dispose)
-    }
-  }
-
-  return {
-    capture(sessionId) {
-      const id = typeof sessionId === 'string' ? sessionId : ''
-      if (!enabled || !id) return { assert() {} }
-      const captured = states.get(id)
-      const generation = captured?.generation ?? 0
-      return {
-        id,
-        generation,
-        assert(phase = 'commit') {
-          const current = states.get(id)
-          if (!current || !current.active || current.generation !== generation) {
-            throw staleSessionError(id, phase)
-          }
-        },
-      }
-    },
-    dispose() {
-      while (disposers.length > 0) disposers.pop()?.()
-    },
-  }
-}
-
-export { STALE_SESSION_CODE }

package/lib/web-search-store.js

@@ -1,181 +0,0 @@
-import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
-import { basename, dirname, join } from 'node:path'
-import { randomUUID } from 'node:crypto'
-import { ensurePrivateFileAcl } from './private-file.js'
-
-const LOCK_STALE_MS = 30 * 1000
-const LOCK_WAIT_MS = 5 * 1000
-
-function sleepSync(milliseconds) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds)
-}
-
-function processAlive(pid) {
-  if (!Number.isSafeInteger(pid) || pid <= 0) return false
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (error) {
-    return error?.code === 'EPERM'
-  }
-}
-
-function staleLockSnapshot(file) {
-  try {
-    const info = statSync(file)
-    const text = readFileSync(file, 'utf8')
-    const [pidText, startedAtText] = text.split(/\r?\n/u)
-    const pid = Number(pidText)
-    const startedAt = Number(startedAtText)
-    const age = Date.now() - Math.max(info.mtimeMs, Number.isFinite(startedAt) ? startedAt : 0)
-    if (age <= LOCK_STALE_MS || processAlive(pid)) return undefined
-    return { text, mtimeMs: info.mtimeMs, size: info.size }
-  } catch {
-    return undefined
-  }
-}
-
-function unlinkLockIfUnchanged(file, snapshot) {
-  if (!snapshot) return false
-  try {
-    const info = statSync(file)
-    if (info.mtimeMs !== snapshot.mtimeMs || info.size !== snapshot.size || readFileSync(file, 'utf8') !== snapshot.text) return false
-    unlinkSync(file)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function signature(file) {
-  try {
-    const value = statSync(file)
-    return `${value.mtimeMs}:${value.ctimeMs}:${value.size}`
-  } catch (error) {
-    if (error?.code === 'ENOENT') return undefined
-    throw error
-  }
-}
-
-export class AtomicWebSearchStore {
-  constructor(file, { empty, validate, corruptCode, writeCode, maxBytes = 2 * 1024 * 1024 }) {
-    this.file = file
-    this.lockFile = `${file}.lock`
-    this.empty = empty
-    this.validate = validate
-    this.corruptCode = corruptCode
-    this.writeCode = writeCode
-    this.maxBytes = maxBytes
-    this.fileSignature = undefined
-    this.data = this.load()
-  }
-
-  error(message, code, cause) {
-    const error = new Error(message, cause === undefined ? undefined : { cause })
-    error.code = code
-    return error
-  }
-
-  load(repairAcl = true) {
-    try {
-      const text = readFileSync(this.file, 'utf8')
-      if (Buffer.byteLength(text, 'utf8') > this.maxBytes) throw this.error(`Web Search store exceeds ${this.maxBytes} bytes`, this.corruptCode)
-      const parsed = JSON.parse(text)
-      if (!this.validate(parsed)) throw this.error(`Invalid Web Search store ${this.file}`, this.corruptCode)
-      this.fileSignature = signature(this.file)
-      return parsed
-    } catch (error) {
-      if (error?.code === 'ENOENT') {
-        this.fileSignature = undefined
-        return this.empty()
-      }
-      if (repairAcl && ['EACCES', 'EPERM'].includes(error?.code) && ensurePrivateFileAcl(this.file)) {
-        return this.load(false)
-      }
-      if (error?.code === this.corruptCode) throw error
-      throw this.error(`Unable to load Web Search store ${this.file}`, this.corruptCode, error)
-    }
-  }
-
-  refresh() {
-    if (signature(this.file) !== this.fileSignature) this.data = this.load()
-  }
-
-  update(mutator) {
-    mkdirSync(dirname(this.file), { recursive: true })
-    ensurePrivateFileAcl(dirname(this.file))
-    const release = this.acquireLock()
-    try {
-      const current = this.load()
-      const next = mutator(structuredClone(current))
-      this.saveUnlocked(next)
-      return structuredClone(next)
-    } finally {
-      release()
-    }
-  }
-
-  acquireLock() {
-    const started = Date.now()
-    while (Date.now() - started <= LOCK_WAIT_MS) {
-      const token = randomUUID()
-      const lockText = `${process.pid}\n${Date.now()}\n${token}\n`
-      let fd
-      let created = false
-      try {
-        fd = openSync(this.lockFile, 'wx', 0o600)
-        created = true
-        if (!ensurePrivateFileAcl(this.lockFile)) throw new Error(`Unable to apply private ACL to Web Search store lock ${this.lockFile}`)
-        writeFileSync(fd, lockText, { encoding: 'utf8' })
-        fsyncSync(fd)
-        closeSync(fd)
-        fd = undefined
-        return () => {
-          try {
-            if (readFileSync(this.lockFile, 'utf8') === lockText) unlinkSync(this.lockFile)
-          } catch {
-            // A crashed owner may have left a lock that was recovered by another writer.
-          }
-        }
-      } catch (error) {
-        if (fd !== undefined) {
-          try { closeSync(fd) } catch {}
-        }
-        if (created) {
-          try { unlinkSync(this.lockFile) } catch {}
-        }
-        if (error?.code !== 'EEXIST') throw this.error(`Unable to acquire Web Search store lock ${this.lockFile}`, this.writeCode, error)
-        if (unlinkLockIfUnchanged(this.lockFile, staleLockSnapshot(this.lockFile))) continue
-        sleepSync(10)
-      }
-    }
-    throw this.error(`Timed out acquiring Web Search store lock ${this.lockFile}`, this.writeCode)
-  }
-
-  saveUnlocked(data) {
-    if (!this.validate(data)) throw this.error(`Refusing to write invalid Web Search store ${this.file}`, this.writeCode)
-    const serialized = JSON.stringify(data, null, 2)
-    if (Buffer.byteLength(serialized, 'utf8') > this.maxBytes) throw this.error(`Web Search store exceeds ${this.maxBytes} bytes`, this.writeCode)
-    const directory = dirname(this.file)
-    const temporary = join(directory, `.${basename(this.file)}.${randomUUID()}.tmp`)
-    let fd
-    try {
-      fd = openSync(temporary, 'wx', 0o600)
-      if (!ensurePrivateFileAcl(temporary)) throw new Error(`Unable to apply private ACL to Web Search store temporary file ${temporary}`)
-      writeFileSync(fd, serialized, { encoding: 'utf8' })
-      fsyncSync(fd)
-      closeSync(fd)
-      fd = undefined
-      renameSync(temporary, this.file)
-      ensurePrivateFileAcl(this.file)
-      this.fileSignature = signature(this.file)
-      this.data = data
-    } catch (error) {
-      if (fd !== undefined) {
-        try { closeSync(fd) } catch {}
-      }
-      try { unlinkSync(temporary) } catch {}
-      throw this.error(`Unable to atomically write Web Search store ${this.file}`, this.writeCode, error)
-    }
-  }
-}