@planet-matrix/mobius-model 0.9.0 → 0.10.1

package/src/exception/README.md

@@ -2,49 +2,57 @@
 
 ## Description
 
-Exception 模块提供围绕宿主环境全局异常入口（global exception entry）的监听、标准化与组合能力，用于把浏览器和 Node.js 暴露出来的异常来源整理成稳定、可清理、可组合的公共异常模型。
+Exception 模块提供围绕异常（exception）的基础模型能力，用于承载宿主环境全局异常入口的监听与标准化，以及其中一类可判别、可匹配、可序列化的结构化错误建模。
 
-它关注的是“异常从哪里被捕获、如何被整理成稳定记录”，而不是“异常之后如何打印、上报、恢复、吞掉或终止进程”。
+它关注的是“异常从哪里进入系统、错误如何被稳定表达”，而不是“异常之后如何打印、上报、恢复、吞掉或终止进程”。
 
 ## For Understanding
 
-理解 Exception 模块时，应把它视为“异常来源层”，而不是“异常处理策略层”。这个模块的职责边界非常明确：
+理解 Exception 模块时，更合适的方式是把它视为“异常模型层”，而不是“异常处理策略层”。这个模块当前关注的是异常这一上位概念，其中既包括异常如何从宿主环境进入系统，也包括其中一类适合被稳定建模的异常形式，也就是结构化错误。
 
-- 它负责封装宿主提供的全局异常入口。
-- 它负责把宿主原始事件整理成更稳定的异常记录结构。
-- 它负责提供可清理的监听语义与批量组合入口。
-- 它不负责日志发送、监控上报、默认阻止、错误恢复或退出进程等策略决策。
+- 宿主异常入口：负责封装浏览器和 Node.js 暴露出来的全局异常入口，并把原始输入整理成稳定记录。
+- 结构化错误：负责把应用内部需要长期存在的某些异常表达成带判别信息的 Error 变体，以便进行分派、组合和序列化。
 
-当前模块主要覆盖两类宿主：
+之所以可以把它们放在同一模块内，不是因为它们的实现方式相似，而是因为它们都在回答同一类问题：系统中的异常应该以什么稳定模型进入后续流程。前者解决“异常从哪里来”，后者解决“某些异常在系统中应如何被表达与判别”。
+
+因此，这个模块并不承担日志发送、监控上报、错误恢复、默认阻止、重试编排或进程退出等策略职责。它只负责把异常整理成更稳定、更清楚、更可组合的输入模型，让上层的 logger、telemetry、workflow、Result/Either 或业务恢复逻辑在其之上继续工作。
+
+对于宿主异常入口部分，当前主要覆盖两类运行时：
 
 - 浏览器侧异常入口，例如 `error` 事件、`window.onerror` 与 `unhandledrejection`。
 - Node.js 侧异常入口，例如 `uncaughtExceptionMonitor`、`uncaughtException` 与 `unhandledRejection`。
 
-在建模上，这个模块采用“保留来源差异，同时提供标准化记录”的方式，而不是过早追求绝对统一。也就是说，浏览器与 Node.js 的来源种类、原始参数和补充字段可以不同，但它们都可以被整理成带有 runtime、source、exception、message、timestamp 等稳定字段的公共记录。这种分层有助于同时满足宿主特定处理与跨宿主消费。
+对于异常建模中的结构化错误部分，当前采用 Tagged Error 的思路：这类错误既保留原生 Error 的 name、message、stack 与 `cause` 语义，也额外拥有稳定的 `tag` 与 `data` 字段，便于在联合类型中进行穷举或部分匹配。
 
 ## For Using
 
-当应用需要在入口层、基础设施层、日志层或诊断层统一接入宿主全局异常时，可以使用这个模块，把分散在不同宿主 API 上的异常来源整理成更清楚的订阅接口。
+当应用需要从宿主环境统一接入全局异常，并把这些异常整理成稳定记录时，可以使用这个模块的异常入口能力，把分散在不同运行时 API 上的异常来源收敛成更清楚的订阅接口。
+
+当应用需要在模块边界、基础设施层、工作流编排、Result/Either 风格流程或跨层协议中表达一组稳定、可判别、可序列化的异常时，也可以使用这个模块中的结构化错误能力，把其中适合显式建模的一类异常从“临时字符串或松散对象”提升为更清楚的公共模型。
 
 当前公共能力大致可以按以下几类理解：
 
-- 单一入口监听：用于单独监听浏览器或 Node.js 的某一种异常来源。
-- 批量入口监听：用于按宿主一次性安装一组常见异常入口，并返回统一清理函数。
+- 单一入口监听：用于单独监听浏览器或 Node.js 的某一种全局异常来源。
+- 批量入口监听：用于按运行时一次性安装一组常见异常入口，并返回统一清理函数。
 - 异常记录标准化：用于把浏览器或 Node.js 的原始输入整理成稳定的异常记录结构。
-- 类型与清理语义：用于表达异常来源种类、记录形状以及取消监听的统一返回类型。
+- Tagged Error 建模：用于定义一类带 `tag`、`data`、`cause` 与序列化能力的结构化异常类型。
+- Tagged Error 匹配：用于按 tag 分派这一类结构化异常的处理逻辑，并在类型层保留分支信息。
+- 类型与清理语义：用于表达异常来源种类、异常记录形状、结构化异常实例能力以及取消监听的统一返回类型。
 
-使用时应把它接在 logger、遥测、监控、恢复策略或业务错误处理的上游，而不是期待它直接替代这些能力。它更适合作为异常输入层，而不是最终处理层。
+使用时应把它接在 logger、遥测、监控、恢复策略或业务错误处理的上游，而不是期待它直接替代这些能力。更准确地说，它适合作为异常输入与异常表达的基础层，而不是最终处理层。
 
 ## For Contributing
 
-贡献 Exception 模块时，应优先判断新增能力是否表达了稳定、可复用的宿主级异常来源，还是只是某个框架、某个应用内部错误流的便捷包装。只有前者才适合进入这个模块。
+贡献 Exception 模块时，应优先判断新增能力是否真正扩展了“异常模型”这个问题域，而不是只是在当前实现里顺手添加一个便捷函数。只有当某项能力表达了稳定、可复用、值得长期维护的异常来源语义，或表达了某类异常的稳定建模语义时，它才适合进入这个模块。
 
 在扩展时，应优先遵守以下边界：
 
-- 公共能力应围绕宿主异常入口、标准化记录与监听清理语义展开。
-- 不要在监听逻辑中默认执行日志输出、上报请求、`preventDefault`、`process.exit` 或其它强策略动作，除非 API 名称与文档已经明确承诺。
+- 公共能力应围绕宿主异常入口、异常记录标准化，以及其中可被稳定表达的结构化异常建模与匹配语义展开。
+- 若新增的是模块内稳定异常模型，且它适合以 Error 形式存在，应优先使用 Tagged Error 形式表达，而不是仅靠裸字符串或无判别字段的对象。
+- 不要在监听逻辑或异常模型中默认执行日志输出、上报请求、`preventDefault`、`process.exit`、重试、恢复或其它强策略动作，除非 API 名称与文档已经明确承诺。
 - 组合入口只负责批量安装监听器与汇总清理，不负责掩盖宿主差异或替调用方做策略决策。
-- 与 Environment 的关系应保持清楚：Environment 可以帮助判断和获取宿主上下文，Exception 则负责安装异常监听器。
+- Tagged Error 的职责是提供一类稳定异常表达、判别和匹配语义，而不是承载某个单一应用的临时上下文容器。
+- 与 Environment 的关系应保持清楚：Environment 可以帮助判断和获取宿主上下文，Exception 则负责异常入口与异常模型本身。
 
 ### JSDoc 注释格式要求
 
@@ -82,7 +90,7 @@ Exception 模块提供围绕宿主环境全局异常入口（global exception en
 - 保持内部辅助项和内部符号为私有，不要让外部接入依赖临时性的内部结构。
 - 每个模块都应有一个用于重导出所有公共 API 的 Barrel 文件。
 - Barrel 文件应命名为 `index.ts`，放在模块目录根部，并且所有公共 API 都应从该文件导出。
-- 新增公共能力时，应优先检查它是否表达稳定、清楚且值得长期维护的异常入口语义，而不是某段实现细节的便捷暴露；仅在确认需要长期对外承诺时再加入 Barrel 导出。
+- 新增公共能力时，应优先检查它是否表达稳定、清楚且值得长期维护的异常模型语义，而不是某段实现细节的便捷暴露；仅在确认需要长期对外承诺时再加入 Barrel 导出。
 
 ### 测试要求
 
@@ -94,3 +102,4 @@ Exception 模块提供围绕宿主环境全局异常入口（global exception en
 - 若该模块不需要测试，必须在说明文件中明确说明该模块不需要测试，并说明理由。一般来说，只有在该模块没有可执行的公共函数、只承载类型层表达，或其语义已被上层模块的测试完整覆盖且重复测试几乎不再带来额外价值时，才适合这样处理。
 - 模块的单元测试文件目录是 `./tests/unit/exception`，若模块包含子模块，则子模块的单元测试文件目录为 `./tests/unit/exception/<sub-module-name>`。
 - 测试应重点覆盖监听注册、清理行为、默认包含的入口集合、记录标准化结果，以及宿主不可用时的失败或空操作语义是否稳定。
+- 若新增 Tagged Error 能力，应重点覆盖 tag 判别、message 与 `cause` 推导、序列化结果，以及按 tag 进行穷举或部分匹配时的返回语义是否稳定。

package/src/exception/error/error.ts

@@ -0,0 +1,123 @@
+
+const isString = (value: unknown): value is string => {
+  return typeof value === "string"
+}
+const isObject = (value: unknown): value is object => {
+  return typeof value === "object" && value !== null
+}
+const extractMessage = (data: unknown): string | undefined => {
+  if (isString(data)) {
+    return data
+  } else if (isObject(data) && "message" in data && isString(data.message)) {
+    return data.message
+  } else {
+    return undefined
+  }
+}
+const extractCause = (data: unknown): unknown => {
+  if (isObject(data) && "cause" in data) {
+    return data.cause
+  } else {
+    return undefined
+  }
+}
+const formatCauseStack = (cause: unknown): string => {
+  if ((cause instanceof Error) === false || cause.stack === undefined) {
+    return ""
+  }
+  const indented = cause.stack.replaceAll("\n", "\n  ")
+  return `\nCaused by: ${indented}`
+}
+const serializeCause = (cause: unknown): unknown => {
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message, stack: cause.stack };
+  }
+  return cause
+}
+
+export interface SerializedTaggedError<Tag extends string, Data = unknown> {
+  version: "1" // for future compatibility
+  tag: Tag
+  data: Data
+  name: string
+  message: string
+  cause: unknown | undefined
+  stack: string | undefined
+  timestamp: number
+}
+export interface TaggedErrorAugments<Tag extends string, Data = unknown> {
+  readonly tag: Tag
+  readonly data: Data
+  toJSON(): SerializedTaggedError<Tag, Data>
+}
+export type TaggedErrorInstance<Tag extends string, Data = unknown> =
+  & Error
+  & TaggedErrorAugments<Tag, Data>
+export type TaggedErrorConstructor<Tag extends string, Data = unknown> = {
+  new(data: Data): TaggedErrorInstance<Tag, Data>
+  is(target: unknown): target is TaggedErrorInstance<Tag, Data>
+}
+export const createTaggedError = <const Tag extends string>(tag: Tag) => {
+  return <Data = unknown>(): TaggedErrorConstructor<Tag, Data> => {
+    return class Impl extends Error {
+      readonly tag: Tag
+      readonly data: Data
+
+      constructor(data: Data) {
+        const message = extractMessage(data)
+        const cause = extractCause(data)
+
+        super(message, cause !== undefined ? { cause } : undefined)
+        Object.setPrototypeOf(this, new.target.prototype)
+        this.name = tag
+        this.stack = `${this.stack}${formatCauseStack(cause)}`
+
+        this.tag = tag
+        this.data = data
+      }
+
+      static is(target: unknown): target is TaggedErrorInstance<Tag, Data> {
+        if (target instanceof Impl) {
+          return true
+        }
+        if (isTaggedError(target) && target.tag === tag) {
+          return true
+        }
+        return false
+      }
+
+      toJSON(): SerializedTaggedError<Tag, Data> {
+        return {
+          version: "1",
+          tag: this.tag,
+          data: this.data,
+          name: this.name,
+          message: this.message,
+          cause: serializeCause(this.cause),
+          stack: this.stack,
+          timestamp: Date.now(),
+        }
+      }
+    }
+  }
+}
+
+export type AnyTaggedError = TaggedErrorInstance<string, unknown>
+export const isTaggedError = (target: unknown): target is AnyTaggedError => {
+  if (typeof target !== "object" || target === null) {
+    return false
+  }
+  if (target instanceof Error === false) {
+    return false
+  }
+  if (!("tag" in target) || typeof target.tag !== "string") {
+    return false
+  }
+  if (!("data" in target)) {
+    return false
+  }
+  if (!("toJSON" in target) || typeof target.toJSON !== "function") {
+    return false
+  }
+  return true
+}

package/src/exception/error/index.ts

@@ -0,0 +1,2 @@
+export * from "./error.ts"
+export * from "./match.ts"

package/src/exception/error/match.ts

@@ -0,0 +1,38 @@
+import type { AnyTaggedError } from "./error.ts"
+
+export type MatchTaggedErrorHandlers<E extends AnyTaggedError, R> = {
+  [Tag in E["tag"]]: (error: Extract<E, { tag: Tag }>) => R
+}
+export const matchTaggedError = <E extends AnyTaggedError, R>(
+  taggedError: E,
+  handlers: MatchTaggedErrorHandlers<E, R>,
+): R => {
+  const handler = handlers[taggedError.tag as E["tag"]]
+  if (handler === undefined) {
+    throw new Error(`No handler for tag: ${taggedError.tag}`)
+  }
+  return handler(taggedError as Extract<E, { tag: E["tag"] }>)
+}
+
+export type MatchTaggedErrorPartialHandlers<E extends AnyTaggedError, R> = {
+  [Tag in E["tag"]]?: ((error: Extract<E, { tag: Tag }>) => R) | undefined
+}
+type UnhandledTaggedError<E extends AnyTaggedError, H> = Exclude<
+  E,
+  { tag: keyof H }
+>
+export const matchTaggedErrorPartial = <
+  E extends AnyTaggedError,
+  R,
+  const Handlers extends MatchTaggedErrorPartialHandlers<E, R> = MatchTaggedErrorPartialHandlers<E, R>
+>(
+  taggedError: E,
+  handlers: Handlers,
+  fallback: (error: UnhandledTaggedError<E, Handlers>) => R,
+): R => {
+  const handler = handlers[taggedError.tag as E["tag"]]
+  if (handler !== undefined) {
+    return handler(taggedError as Extract<E, { tag: E["tag"] }>)
+  }
+  return fallback(taggedError as UnhandledTaggedError<E, Handlers>)
+}

package/src/exception/error/must-fix.ts

@@ -0,0 +1,17 @@
+import { createTaggedError } from "./error.ts"
+import type { TaggedErrorConstructor } from "./error.ts"
+
+const MustFixErrorBase: TaggedErrorConstructor<"MustFix", {
+  message: string
+  cause?: unknown
+}> = createTaggedError("MustFix")()
+export class MustFixError extends MustFixErrorBase {
+  //
+}
+
+export const mustFixError = (message: string, options?: { cause?: unknown }): MustFixError => {
+  return new MustFixError({ message, cause: options?.cause })
+}
+export const isMustFixError = (error: unknown): error is MustFixError => {
+  return MustFixError.is(error)
+}

package/src/exception/index.ts

@@ -2,3 +2,5 @@ export type * from "./types.ts"
 export * from "./normalize.ts"
 export * from "./browser.ts"
 export * from "./nodejs.ts"
+
+export * from "./error/index.ts"

package/src/file-system/find.ts

@@ -0,0 +1,53 @@
+import { statSync } from "node:fs"
+import { dirname, join, parse, resolve } from "node:path"
+import type { ResolveFriendlyOptions } from "./resolve.ts"
+import { resolveStartPath } from "./resolve.ts"
+
+export interface GetClosestFilePathOptions extends ResolveFriendlyOptions {
+  targetBase: string
+}
+/**
+ * 从 {@link ResolveFriendlyOptions.startPath} 开始，逐级向上查找，直到找到指定的文件为止，并返回该文件的路径。
+ * 若未找到指定的文件，则返回 undefined。
+ */
+export const getClosestFilePath = (
+  options: GetClosestFilePathOptions
+): string | undefined => {
+  const { targetBase } = options
+
+  const startPath = resolveStartPath(options)
+
+  let currentDir = startPath
+
+  try {
+    const stat = statSync(startPath)
+    if (stat.isFile()) {
+      currentDir = dirname(startPath)
+    }
+  } catch {
+    currentDir = dirname(startPath)
+  }
+
+  const { root } = parse(currentDir)
+
+  while (true) {
+    const filePath = resolve(join(currentDir, targetBase))
+
+    try {
+      const stat = statSync(filePath)
+      if (stat.isFile()) {
+        return filePath
+      }
+    } catch {
+      //
+    }
+
+    if (currentDir === root) {
+      break
+    }
+
+    currentDir = dirname(currentDir)
+  }
+
+  return undefined
+}

package/src/file-system/index.ts

@@ -0,0 +1,2 @@
+export * from "./path.ts"
+export * from "./find.ts"

package/src/file-system/path.ts

@@ -0,0 +1,76 @@
+import { join, parse } from "node:path"
+import { fileURLToPath } from "node:url"
+
+export type PathString = string
+export interface PathObject {
+  path: string
+  root: string
+  dir: string
+  base: string
+  ext: string
+  name: string
+  separator: string
+}
+export type PathUnion = PathString | PathObject
+
+export const pathStringToObject = (pathString: string): PathObject => {
+  const pathObject = parse(pathString)
+
+  return {
+    root: pathObject.root,
+    path: pathString,
+    dir: pathObject.dir,
+    base: pathObject.base,
+    ext: pathObject.ext,
+    name: pathObject.name,
+    separator: join("a", "b").replaceAll('a', "").replaceAll('b', "")
+  }
+}
+
+export const pathObjectToString = (pathObject: PathObject): string => {
+  return pathObject.path
+}
+
+export const toPathObject = (path: PathUnion): PathObject => {
+  if (typeof path === "string") {
+    if (isFileUrl(path)) {
+      return fileUrlToPathObject(path)
+    } else {
+      return pathStringToObject(path)
+    }
+  } else {
+    return path
+  }
+}
+
+export const toPathString = (path: PathUnion): string => {
+  if (typeof path === "string") {
+    if (isFileUrl(path)) {
+      return fileUrlToPathString(path)
+    } else {
+      return path
+    }
+  } else {
+    return pathObjectToString(path)
+  }
+}
+
+export const isFileUrl = (url: string): boolean => {
+  try {
+    const parsedUrl = new URL(url)
+    return parsedUrl.protocol === "file:"
+  } catch {
+    return false
+  }
+}
+
+export const fileUrlToPathString = (fileUrl: string): PathString => {
+  return fileURLToPath(fileUrl)
+}
+
+export const fileUrlToPathObject = (fileUrl: string): PathObject => {
+  const pathString = fileUrlToPathString(fileUrl)
+  const pathObject = pathStringToObject(pathString)
+
+  return pathObject
+}

package/src/file-system/resolve.ts

@@ -0,0 +1,22 @@
+import { isAbsolute, join, resolve } from "node:path"
+
+export interface ResolveFriendlyOptions {
+  startPath?: string | undefined
+}
+export const resolveStartPath = (options: ResolveFriendlyOptions): string => {
+  const { startPath } = options
+
+  if (startPath === undefined) {
+    return getCurrentWorkingDirectory()
+  }
+
+  if (isAbsolute(startPath)) {
+    return startPath
+  }
+
+  return resolve(join(getCurrentWorkingDirectory(), startPath))
+}
+
+export const getCurrentWorkingDirectory = (): string => {
+  return process.cwd()
+}

package/src/form/inputor-controller/base.ts

@@ -469,7 +469,6 @@ export abstract class BaseInputorController<
 
   async getSchema(): Promise<Schema> {
     await this.waitForReady()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const schema: Schema = {
       inputorTypeName: this.inputorTypeName,
       id: this.id,
@@ -488,7 +487,6 @@ export abstract class BaseInputorController<
 
   async getContext(): Promise<Context> {
     const schema = await this.getSchema()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const context: Context = {
       ...schema,
       internalValue: this.getInternalValue(),
@@ -529,21 +527,16 @@ export abstract class BaseInputorController<
     if (typeof schema !== "object" || schema === null) {
       return false
     }
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const externalSchema = schema as Schema
     const internalSchema = await this.getSchema()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const partialExternalSchema = {} as Schema
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const partialInternalSchema = {} as Schema
     Object.keys(externalSchema).forEach((key) => {
       if (key in internalSchema) {
         Object.assign(partialInternalSchema, {
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion
           [key]: (internalSchema as Record<string, unknown>)[key],
         })
         Object.assign(partialExternalSchema, {
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion
           [key]: (externalSchema as Record<string, unknown>)[key],
         })
       }
@@ -561,12 +554,10 @@ export abstract class BaseInputorController<
   }
 
   protected async internalValueToExternalValue(internalValue: InternalValue): Promise<ExternalValue> {
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await Promise.resolve(internalValue as unknown as ExternalValue)
   }
 
   protected async externalValueToInternalValue(externalValue: ExternalValue): Promise<InternalValue> {
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await Promise.resolve(externalValue as unknown as InternalValue)
   }
 
@@ -659,17 +650,13 @@ export abstract class BaseInputorController<
     }
 
     const isSameSchema = await this.isSameSchema(
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       nextContext as unknown as Schema,
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       prevContext as unknown as Schema,
     )
     if (isSameSchema === false) {
       this.log("[doUpdate] schema changed", "prevSchema", prevContext, "nextSchema", nextContext)
       this.emitSchemaChange({
-        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
         newSchema: nextContext as unknown as Schema,
-        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
         oldSchema: prevContext as unknown as Schema,
       })
     }

package/src/form/inputor-controller/form.ts

@@ -113,7 +113,6 @@ export class FormInputorController<
           this.voidExternalValue = options.voidExternalValue
         }
         else {
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion
           this.voidExternalValue = VOID_EXTERNAL_VALUE as unknown as ExternalValue
         }
         this.items = options.items
@@ -139,7 +138,6 @@ export class FormInputorController<
   }
 
   protected async getSchemaDict(): Promise<GetSchemaDict<Items>> {
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     const schemaDict = {} as GetSchemaDict<Items>
     await Promise.all(Object.entries(this.items).map(async ([key, item]) => {
       Object.assign(schemaDict, {

package/src/http/api/api-type.ts

@@ -18,7 +18,6 @@ export type ApiType<Target extends AnyApiSchema> = Target extends ApiSchema<
   outputError: StandardSchemaV1.InferOutput<OutputErrorSchema>
 } : never
 export const apiType = <const Target extends AnyApiSchema>(apiSchema: Target): ApiType<Target> => {
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return apiSchema as unknown as ApiType<Target>
 }
 
@@ -26,12 +25,10 @@ export type ApiTypesInTuple<Target extends readonly AnyApiSchema[]> = {
   [Index in keyof Target]: ApiType<Target[Index]>
 }
 export const apiTypesInTuple = <const Target extends readonly AnyApiSchema[]>(apiSchemas: Target): ApiTypesInTuple<Target> => {
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return apiSchemas.map(apiSchema => apiType(apiSchema)) as unknown as ApiTypesInTuple<Target>
 }
 
 export type ApiTypesInUnion<Target extends readonly AnyApiSchema[]> = ApiType<Target[number]>
 export const apiTypesInUnion = <const Target extends readonly AnyApiSchema[]>(apiSchemas: Target): ApiTypesInUnion<Target> => {
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return apiSchemas.map(apiSchema => apiType(apiSchema)) as unknown as ApiTypesInUnion<Target>
 }

package/src/http/api-adapter/api-result-arktype.ts

@@ -71,7 +71,6 @@ export const commonJsonSuccessResultSchema = <Data extends Record<string, unknow
 ): CommonJsonSuccessResultSchema<Data> => {
   // arktype's instantiated object schema is compatible here but
   // not assignable through its generic facade
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return type({
     status: "'success'",
     data: dataSchema,
@@ -229,11 +228,9 @@ export const commonJsonErrorResultSchema = <
 >(
   dataSchema: Type<Data>
 ): CommonJsonErrorResultSchema<Data> => {
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
   return type({
     status: "'error'",
     data: type.and(
-      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
       dataSchema as Type<{
         reason: string
         reasonDetail?: string | undefined

package/src/index.ts

@@ -16,6 +16,7 @@ export * as Route from "./route/index.ts"
 export * as Timer from "./timer/index.ts"
 export * as Cron from "./cron/index.ts"
 export * as Orchestration from "./orchestration/index.ts"
+export * as Service from "./service/index.ts"
 export * as Socket from "./socket/index.ts"
 export * as Http from "./http/index.ts"
 
@@ -35,3 +36,4 @@ export * as Huawei from "./huawei/index.ts"
 export * as Openai from "./openai/index.ts"
 export * as Weixin from "./weixin/index.ts"
 export * as Ai from "./ai/index.ts"
+export * as FileSystem from "./file-system/index.ts"

package/src/openai/openai.ts

@@ -292,7 +292,6 @@ export class Openai implements LoggerFriendly {
             }
             const textDecoder = new TextDecoder()
             const decoded = textDecoder.decode(chunk.value)
-            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
             const parsed = JSON.parse(decoded) as OriginalChatCompletionChunkResult
             // logger.log("Original chat completion api's stream chunk:", JSON.stringify(parsed))
             controller.enqueue(parsed)

package/src/request/fetch/browser.ts

@@ -229,7 +229,6 @@ export class BrowserFetch<
    */
   async getJson(): Promise<FetchOutputJsonData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.json() as FetchOutputJsonData<Output>
   }
 
@@ -238,7 +237,6 @@ export class BrowserFetch<
    */
   async getText(): Promise<FetchOutputTextData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.text() as FetchOutputTextData<Output>
   }
 
@@ -247,7 +245,6 @@ export class BrowserFetch<
    */
   async getBlob(): Promise<FetchOutputBlobData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.blob() as FetchOutputBlobData<Output>
   }
 
@@ -256,7 +253,6 @@ export class BrowserFetch<
    */
   async getArrayBuffer(): Promise<FetchOutputArrayBufferData<Output>> {
     const response = await this.getResponse()
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return await response.arrayBuffer() as FetchOutputArrayBufferData<Output>
   }
 
@@ -270,7 +266,6 @@ export class BrowserFetch<
       throw new Error("Response body stream is unavailable.")
     }
 
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
     return response.body as FetchOutputStreamData<Output>
   }
 }