onlycode 1.18.0 → 1.19.0

package/src/tool/websearch.ts

@@ -1,145 +0,0 @@
-import { Effect, Schema } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import * as Tool from "./tool"
-import * as McpWebSearch from "./mcp-websearch"
-import DESCRIPTION from "./websearch.txt"
-import DESCRIPTION_ZH from "./websearch.zh.txt"
-import { checksum } from "@opencode-ai/core/util/encode"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { loadDescription } from "./description"
-
-export const Parameters = Schema.Struct({
-  query: Schema.String.annotate({ description: "Websearch query" }),
-  numResults: Schema.optional(Schema.Number).annotate({
-    description: "Number of search results to return (default: 8)",
-  }),
-  livecrawl: Schema.optional(Schema.Literals(["fallback", "preferred"])).annotate({
-    description:
-      "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
-  }),
-  type: Schema.optional(Schema.Literals(["auto", "fast", "deep"])).annotate({
-    description: "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search",
-  }),
-  contextMaxCharacters: Schema.optional(Schema.Number).annotate({
-    description: "Maximum characters for context string optimized for LLMs (default: 10000)",
-  }),
-})
-
-const WebSearchProviderSchema = Schema.Literals(["exa", "parallel"])
-export type WebSearchProvider = Schema.Schema.Type<typeof WebSearchProviderSchema>
-
-export function selectWebSearchProvider(sessionID: string, flags = { exa: false, parallel: false }): WebSearchProvider {
-  const override = process.env.OPENCODE_WEBSEARCH_PROVIDER
-  if (override === "exa" || override === "parallel") return override
-  if (flags.parallel) return "parallel"
-  if (flags.exa) return "exa"
-
-  return Number.parseInt(checksum(sessionID) ?? "0", 36) % 2 === 0 ? "exa" : "parallel"
-}
-
-export function webSearchProviderLabel(provider: unknown) {
-  if (provider === "parallel") return "Parallel Web Search"
-  if (provider === "exa") return "Exa Web Search"
-  return "Web Search"
-}
-
-export function webSearchModelName(extra: Tool.Context["extra"]) {
-  const model = extra?.model
-  if (!model || typeof model !== "object") return undefined
-  const api = "api" in model && model.api && typeof model.api === "object" ? model.api : undefined
-  const apiID = api && "id" in api && typeof api.id === "string" ? api.id : undefined
-  const id = "id" in model && typeof model.id === "string" ? model.id : undefined
-  return (apiID ?? id)?.slice(0, 100)
-}
-
-function parallelAuthHeaders() {
-  const headers = { "User-Agent": `opencode/${InstallationVersion}` }
-  if (!process.env.PARALLEL_API_KEY) return headers
-  return { ...headers, Authorization: `Bearer ${process.env.PARALLEL_API_KEY}` }
-}
-
-function callProvider(
-  http: HttpClient.HttpClient,
-  provider: WebSearchProvider,
-  params: Schema.Schema.Type<typeof Parameters>,
-  ctx: Tool.Context,
-) {
-  if (provider === "parallel") {
-    return McpWebSearch.call(
-      http,
-      McpWebSearch.PARALLEL_URL,
-      "web_search",
-      McpWebSearch.ParallelSearchArgs,
-      {
-        objective: params.query,
-        search_queries: [params.query],
-        session_id: ctx.sessionID,
-        model_name: webSearchModelName(ctx.extra),
-      },
-      "25 seconds",
-      parallelAuthHeaders(),
-    )
-  }
-
-  return McpWebSearch.call(
-    http,
-    McpWebSearch.EXA_URL,
-    "web_search_exa",
-    McpWebSearch.SearchArgs,
-    {
-      query: params.query,
-      type: params.type || "auto",
-      numResults: params.numResults || 8,
-      livecrawl: params.livecrawl || "fallback",
-      contextMaxCharacters: params.contextMaxCharacters,
-    },
-    "25 seconds",
-  )
-}
-
-export const WebSearchTool = Tool.define(
-  "websearch",
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-    const flags = yield* RuntimeFlags.Service
-
-    return {
-      get description() {
-        return loadDescription(DESCRIPTION, DESCRIPTION_ZH).replace("{{year}}", new Date().getFullYear().toString())
-      },
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const provider = selectWebSearchProvider(ctx.sessionID, {
-            exa: flags.enableExa,
-            parallel: flags.enableParallel,
-          })
-          const title = webSearchProviderLabel(provider)
-          yield* ctx.metadata({ title: `${title} "${params.query}"`, metadata: { provider } })
-
-          yield* ctx.ask({
-            permission: "websearch",
-            patterns: [params.query],
-            always: ["*"],
-            metadata: {
-              query: params.query,
-              numResults: params.numResults,
-              livecrawl: params.livecrawl,
-              type: params.type,
-              contextMaxCharacters: params.contextMaxCharacters,
-              provider,
-            },
-          })
-
-          const result = yield* callProvider(http, provider, params, ctx)
-
-          return {
-            output: result ?? "No search results found. Please try a different query.",
-            title: `${title}: ${params.query}`,
-            metadata: { provider },
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/websearch.txt

@@ -1,14 +0,0 @@
-- Search the web using the session's web search provider - performs real-time web searches and can scrape content from specific URLs
-- Provides up-to-date information for current events and recent data
-- Supports configurable result counts and returns the content from the most relevant websites
-- Use this tool for accessing information beyond knowledge cutoff
-- Searches are performed automatically within a single API call
-
-Usage notes:
-  - Supports live crawling modes when available: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
-  - Search types when available: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
-  - Configurable context length for optimal LLM integration
-  - Domain filtering and advanced search options available
-
-The current year is {{year}}. You MUST use this year when searching for recent information or current events
-- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"

package/src/tool/websearch.zh.txt

@@ -1,14 +0,0 @@
-- 使用会话的网页搜索提供商搜索网页 - 执行实时网页搜索并可以从特定 URL 抓取内容
-- 提供当前事件和最新数据的最新信息
-- 支持可配置的结果数量并返回来自最相关网站的内容
-- 使用此工具访问超出知识截止日期的信息
-- 搜索在单个 API 调用中自动执行
-
-使用说明：
-  - 支持实时爬取模式（如果可用）：'fallback'（如果缓存不可用则作为备份）或 'preferred'（优先实时爬取）
-  - 搜索类型（如果可用）：'auto'（平衡）、'fast'（快速结果）、'deep'（全面搜索）
-  - 可配置的上下文长度，以实现最佳 LLM 集成
-  - 提供域名筛选和高级搜索选项
-
-当前年份是 {{year}}。在搜索最新信息或当前事件时，您必须使用此年份
-- 示例：如果当前年份是 2026 年，用户询问 "最新 AI 新闻"，请搜索 "AI 新闻 2026"，而不是 "AI 新闻 2025"

package/src/tool/write.ts

@@ -1,106 +0,0 @@
-import { Schema } from "effect"
-import * as path from "path"
-import { Effect } from "effect"
-import * as Tool from "./tool"
-import { LSP } from "@/lsp/lsp"
-import { createTwoFilesPatch } from "diff"
-import DESCRIPTION from "./write.txt"
-import DESCRIPTION_ZH from "./write.zh.txt"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { FileSystem } from "@opencode-ai/core/filesystem"
-import { Watcher } from "@opencode-ai/core/filesystem/watcher"
-import { Format } from "../format"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { InstanceState } from "@/effect/instance-state"
-import { trimDiff } from "./edit"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import * as Bom from "@/util/bom"
-import { loadDescription } from "./description"
-
-const MAX_PROJECT_DIAGNOSTICS_FILES = 5
-
-export const Parameters = Schema.Struct({
-  content: Schema.String.annotate({ description: "The content to write to the file" }),
-  filePath: Schema.String.annotate({
-    description: "The absolute path to the file to write (must be absolute, not relative)",
-  }),
-})
-
-export const WriteTool = Tool.define(
-  "write",
-  Effect.gen(function* () {
-    const lsp = yield* LSP.Service
-    const fs = yield* FSUtil.Service
-    const events = yield* EventV2Bridge.Service
-    const format = yield* Format.Service
-
-    return {
-      description: loadDescription(DESCRIPTION, DESCRIPTION_ZH),
-      parameters: Parameters,
-      execute: (params: { content: string; filePath: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
-          const filepath = path.isAbsolute(params.filePath)
-            ? params.filePath
-            : path.join(instance.directory, params.filePath)
-          yield* assertExternalDirectoryEffect(ctx, filepath)
-
-          const exists = yield* fs.existsSafe(filepath)
-          const source = exists ? yield* Bom.readFile(fs, filepath) : { bom: false, text: "" }
-          const next = Bom.split(params.content)
-          const desiredBom = source.bom || next.bom
-          const contentOld = source.text
-          const contentNew = next.text
-
-          const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, contentNew))
-          yield* ctx.ask({
-            permission: "edit",
-            patterns: [path.relative(instance.worktree, filepath)],
-            always: ["*"],
-            metadata: {
-              filepath,
-              diff,
-            },
-          })
-
-          yield* fs.writeWithDirs(filepath, Bom.join(contentNew, desiredBom))
-          if (yield* format.file(filepath)) {
-            yield* Bom.syncFile(fs, filepath, desiredBom)
-          }
-          yield* events.publish(FileSystem.Event.Edited, { file: filepath })
-          yield* events.publish(Watcher.Event.Updated, {
-            file: filepath,
-            event: exists ? "change" : "add",
-          })
-
-          let output = "Wrote file successfully."
-          yield* lsp.touchFile(filepath, "document")
-          const diagnostics = yield* lsp.diagnostics()
-          const normalizedFilepath = FSUtil.normalizePath(filepath)
-          let projectDiagnosticsCount = 0
-          for (const [file, issues] of Object.entries(diagnostics)) {
-            const current = file === normalizedFilepath
-            if (!current && projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue
-            const block = LSP.Diagnostic.report(current ? filepath : file, issues)
-            if (!block) continue
-            if (current) {
-              output += `\n\nLSP errors detected in this file, please fix:\n${block}`
-              continue
-            }
-            projectDiagnosticsCount++
-            output += `\n\nLSP errors detected in other files:\n${block}`
-          }
-
-          return {
-            title: path.relative(instance.worktree, filepath),
-            metadata: {
-              diagnostics,
-              filepath,
-              exists: exists,
-            },
-            output,
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/write.txt

@@ -1,8 +0,0 @@
-Writes a file to the local filesystem.
-
-Usage:
-- This tool will overwrite the existing file if there is one at the provided path.
-- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
-- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
-- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
-- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/tool/write.zh.txt

@@ -1,8 +0,0 @@
-将文件写入本地文件系统。
-
-用法：
-- 如果提供的路径已存在文件，此工具将覆盖该文件。
-- 如果这是现有文件，您必须先使用 Read 工具读取文件内容。如果您未先读取文件，此工具将失败。
-- 始终优先编辑代码库中的现有文件。除非明确要求，否则切勿写入新文件。
-- 切勿主动创建文档文件（*.md）或 README 文件。仅在用户明确请求时才创建文档文件。
-- 仅在用户明确请求时才使用表情符号。除非被要求，否则避免在文件中写入表情符号。

package/src/util/archive.ts

@@ -1,17 +0,0 @@
-import path from "path"
-import * as Process from "./process"
-
-export async function extractZip(zipPath: string, destDir: string) {
-  if (process.platform === "win32") {
-    const winZipPath = path.resolve(zipPath)
-    const winDestDir = path.resolve(destDir)
-    // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
-    const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
-    await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
-    return
-  }
-
-  await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
-}
-
-export * as Archive from "./archive"

package/src/util/bom.ts

@@ -1,27 +0,0 @@
-import { Effect } from "effect"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-
-const BOM_CODE = 0xfeff
-const BOM = String.fromCharCode(BOM_CODE)
-
-export function split(text: string) {
-  if (text.charCodeAt(0) !== BOM_CODE) return { bom: false, text }
-  return { bom: true, text: text.slice(1) }
-}
-
-export function join(text: string, bom: boolean) {
-  const stripped = split(text).text
-  if (!bom) return stripped
-  return BOM + stripped
-}
-
-export const readFile = Effect.fn("Bom.readFile")(function* (fs: FSUtil.Interface, filePath: string) {
-  return split(new TextDecoder("utf-8", { ignoreBOM: true }).decode(yield* fs.readFile(filePath)))
-})
-
-export const syncFile = Effect.fn("Bom.syncFile")(function* (fs: FSUtil.Interface, filePath: string, bom: boolean) {
-  const current = yield* readFile(fs, filePath)
-  if (current.bom === bom) return current.text
-  yield* fs.writeWithDirs(filePath, join(current.text, bom))
-  return current.text
-})

package/src/util/data-url.ts

@@ -1,9 +0,0 @@
-export function decodeDataUrl(url: string) {
-  const idx = url.indexOf(",")
-  if (idx === -1) return ""
-
-  const head = url.slice(0, idx)
-  const body = url.slice(idx + 1)
-  if (head.includes(";base64")) return Buffer.from(body, "base64").toString("utf8")
-  return decodeURIComponent(body)
-}

package/src/util/defer.ts

@@ -1,10 +0,0 @@
-export function defer(fn: () => void | Promise<void>): AsyncDisposable & Disposable {
-  return {
-    [Symbol.dispose]() {
-      void fn()
-    },
-    [Symbol.asyncDispose]() {
-      return Promise.resolve(fn())
-    },
-  }
-}

package/src/util/effect-http-client.ts

@@ -1,11 +0,0 @@
-import { Schedule } from "effect"
-import { HttpClient } from "effect/unstable/http"
-
-export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
-  client.pipe(
-    HttpClient.retryTransient({
-      retryOn: "errors-and-responses",
-      times: 2,
-      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
-    }),
-  )

package/src/util/error.ts

@@ -1 +0,0 @@
-export * from "@opencode-ai/tui/util/error"

package/src/util/filesystem.ts

@@ -1,251 +0,0 @@
-import { chmod, mkdir, readFile, stat as statFile, writeFile } from "fs/promises"
-import { createWriteStream, existsSync, statSync } from "fs"
-import { realpathSync } from "fs"
-import { dirname, isAbsolute, join, resolve as pathResolve, win32 } from "path"
-import { Readable } from "stream"
-import { pipeline } from "stream/promises"
-import { Glob } from "@opencode-ai/core/util/glob"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { fileURLToPath } from "url"
-
-// Fast sync version for metadata checks
-export async function exists(p: string): Promise<boolean> {
-  return existsSync(p)
-}
-
-export async function isDir(p: string): Promise<boolean> {
-  try {
-    return statSync(p).isDirectory()
-  } catch {
-    return false
-  }
-}
-
-export function stat(p: string): ReturnType<typeof statSync> | undefined {
-  return statSync(p, { throwIfNoEntry: false }) ?? undefined
-}
-
-export async function statAsync(p: string): Promise<ReturnType<typeof statSync> | undefined> {
-  return statFile(p).catch((e) => {
-    if (isEnoent(e)) return undefined
-    throw e
-  })
-}
-
-export async function size(p: string): Promise<number> {
-  const s = stat(p)?.size ?? 0
-  return typeof s === "bigint" ? Number(s) : s
-}
-
-export async function readText(p: string): Promise<string> {
-  return readFile(p, "utf-8")
-}
-
-export async function readJson<T = unknown>(p: string): Promise<T> {
-  return JSON.parse(await readFile(p, "utf-8"))
-}
-
-export async function readBytes(p: string): Promise<Buffer> {
-  return readFile(p)
-}
-
-export async function readArrayBuffer(p: string): Promise<ArrayBuffer> {
-  const buf = await readFile(p)
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) as ArrayBuffer
-}
-
-function isEnoent(e: unknown): e is { code: "ENOENT" } {
-  return typeof e === "object" && e !== null && "code" in e && (e as { code: string }).code === "ENOENT"
-}
-
-export async function write(p: string, content: string | Buffer | Uint8Array, mode?: number): Promise<void> {
-  try {
-    if (mode) {
-      await writeFile(p, content, { mode })
-    } else {
-      await writeFile(p, content)
-    }
-  } catch (e) {
-    if (isEnoent(e)) {
-      await mkdir(dirname(p), { recursive: true })
-      if (mode) {
-        await writeFile(p, content, { mode })
-      } else {
-        await writeFile(p, content)
-      }
-      return
-    }
-    throw e
-  }
-}
-
-export async function writeJson(p: string, data: unknown, mode?: number): Promise<void> {
-  return write(p, JSON.stringify(data, null, 2), mode)
-}
-
-export async function writeStream(
-  p: string,
-  stream: ReadableStream<Uint8Array> | Readable,
-  mode?: number,
-): Promise<void> {
-  const dir = dirname(p)
-  if (!existsSync(dir)) {
-    await mkdir(dir, { recursive: true })
-  }
-
-  const nodeStream = stream instanceof ReadableStream ? Readable.fromWeb(stream as any) : stream
-  const writeStream = createWriteStream(p)
-  await pipeline(nodeStream, writeStream)
-
-  if (mode) {
-    await chmod(p, mode)
-  }
-}
-
-export async function mimeType(p: string): Promise<string> {
-  const { lookup } = await import("mime-types")
-  return lookup(p) || "application/octet-stream"
-}
-
-/**
- * On Windows, normalize a path to its canonical casing using the filesystem.
- * This is needed because Windows paths are case-insensitive but LSP servers
- * may return paths with different casing than what we send them.
- */
-export function normalizePath(p: string): string {
-  if (process.platform !== "win32") return p
-  const resolved = win32.normalize(win32.resolve(windowsPath(p)))
-  try {
-    return realpathSync.native(resolved)
-  } catch {
-    return resolved
-  }
-}
-
-export function normalizePathPattern(p: string): string {
-  if (process.platform !== "win32") return p
-  if (p === "*") return p
-  const match = p.match(/^(.*)[\\/]\*$/)
-  if (!match) return normalizePath(p)
-  const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1]
-  return join(normalizePath(dir), "*")
-}
-
-// We cannot rely on path.resolve() here because git.exe may come from Git Bash, Cygwin, or MSYS2, so we need to translate these paths at the boundary.
-// Also resolves symlinks so that callers using the result as a cache key
-// always get the same canonical path for a given physical directory.
-export function resolve(p: string): string {
-  const resolved = pathResolve(windowsPath(p))
-  try {
-    return normalizePath(realpathSync(resolved))
-  } catch (e) {
-    if (isEnoent(e)) return normalizePath(resolved)
-    throw e
-  }
-}
-
-export function resolveFilePath(root: string, file: string): string {
-  const raw = file.startsWith("file://") ? fileURLToPath(file) : file
-  if (isAbsolute(raw)) return raw
-  return pathResolve(root, raw)
-}
-
-export function windowsPath(p: string): string {
-  if (process.platform !== "win32") return p
-  return (
-    p
-      .replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-      // Git Bash for Windows paths are typically /<drive>/...
-      .replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-      // Cygwin git paths are typically /cygdrive/<drive>/...
-      .replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-      // WSL paths are typically /mnt/<drive>/...
-      .replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-  )
-}
-export function overlaps(a: string, b: string) {
-  return FSUtil.overlaps(a, b)
-}
-
-export function contains(parent: string, child: string) {
-  return FSUtil.contains(parent, child)
-}
-
-export async function findUp(
-  target: string,
-  start: string,
-  stop?: string,
-  options?: { rootFirst?: boolean },
-): Promise<string[]>
-export async function findUp(
-  target: string[],
-  start: string,
-  stop?: string,
-  options?: { rootFirst?: boolean },
-): Promise<string[]>
-export async function findUp(
-  target: string | string[],
-  start: string,
-  stop?: string,
-  options?: { rootFirst?: boolean },
-) {
-  const dirs = [start]
-  let current = start
-  while (true) {
-    if (stop === current) break
-    const parent = dirname(current)
-    if (parent === current) break
-    dirs.push(parent)
-    current = parent
-  }
-
-  const targets = Array.isArray(target) ? target : [target]
-  const result = []
-  for (const dir of options?.rootFirst ? dirs.toReversed() : dirs) {
-    for (const item of targets) {
-      const search = join(dir, item)
-      if (await exists(search)) result.push(search)
-    }
-  }
-  return result
-}
-
-export async function* up(options: { targets: string[]; start: string; stop?: string }) {
-  const { targets, start, stop } = options
-  let current = start
-  while (true) {
-    for (const target of targets) {
-      const search = join(current, target)
-      if (await exists(search)) yield search
-    }
-    if (stop === current) break
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-}
-
-export async function globUp(pattern: string, start: string, stop?: string) {
-  let current = start
-  const result = []
-  while (true) {
-    try {
-      const matches = await Glob.scan(pattern, {
-        cwd: current,
-        absolute: true,
-        include: "file",
-        dot: true,
-      })
-      result.push(...matches)
-    } catch {
-      // Skip invalid glob patterns
-    }
-    if (stop === current) break
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-  return result
-}
-
-export * as Filesystem from "./filesystem"

package/src/util/html.ts

@@ -1,8 +0,0 @@
-export function escapeHtml(value: string) {
-  return value
-    .replaceAll("&", "&")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;")
-}

package/src/util/iife.ts

@@ -1,3 +0,0 @@
-export function iife<T>(fn: () => T) {
-  return fn()
-}

package/src/util/lazy.ts

@@ -1,20 +0,0 @@
-export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
-
-  const result = (): T => {
-    if (loaded) return value as T
-    value = fn()
-    loaded = true
-    return value as T
-  }
-
-  result.reset = () => {
-    loaded = false
-    value = undefined
-  }
-
-  result.loaded = () => loaded
-
-  return result
-}