StitchAPI Docs

API 拼接：将任意 API 转换为类型安全、健韧的函数。只需声明一次端点及其类型、身份验证和韧性配置，就能像调用本地函数一样调用它。无需服务端、无需代码生成、无需配置文件。同一份定义既能供你的代码和命令行使用，也能供 AI Agent 使用。

📚 stitchapi.dev — 文档、指南和在线演练场

零运行时依赖 · 约 21 kB（min+gzip） — 通常，import { stitch } 经 tree-shaking 后约为 19 kB；由于没有传递依赖树，也就无需安装或审计其他内容。缓存引擎和 OTLP 导出器会在首次使用时延迟加载，因此不计入这些数据。体积限制是 CI 中强制执行的预算，而非一个目标。

可验证的供应链 — 每个软件包都通过 OIDC 从 GitHub Actions 发布，并附带签名的 npm 构建来源证明，因此你可以确认安装的压缩包由哪个提交和哪个工作流生成。每个版本还会同时提供 SPDX 和 CycloneDX 格式的 SBOM，并由 OpenSSF Scorecard 对代码库进行公开评分。

_观看更多

说明

**StitchAPI 当前版本为 1.0.0-rc.9。**核心运行时已完成全部功能开发、没有依赖、通过了测试门禁，目前已在两个项目的生产环境中运行。我们正在真实环境中验证，然后再发布稳定版 1.0.0 — 请锁定确切版本，并预期只会有少量、文档明确记录的变更。欢迎反馈。

---

目录

• 什么是 stitch？
• 动机
• 为什么选择 StitchAPI
• StitchAPI 不是什么
• 功能
• 安装
• 快速开始
• 组合：seam、extends、.with()
• 验证与分级漂移
• 弹性：重试、限流、超时
• 缓存
• 将身份验证作为边界
• 接口：适用于任何请求方式
• 四种入口
• Agent 原生支持
• 错误与陷阱
• 零基础设施可观测性
• 软件包
• 文档
• 贡献
• 许可证

什么是 stitch？

stitch 是 StitchAPI 的核心原语：它接收单个端点，并返回一个可调用对象。你只需声明一次契约——输入、输出、身份验证、弹性——然后像调用本地函数一样调用它。你的代码、CLI 和 AI Agent 调用的是同一个定义——每个调用方获得的都是能力，而非凭据。包含多个端点的服务称为 seam——一组共享基础 URL、身份验证和一个运行时（限流预算、存储、追踪接收器）的 stitch。

import { stitch } from 'stitchapi';
import { z } from 'zod';

const getUser = stitch({
    path: 'https://api.example.com/users/{id}',
    output: z.object({ id: z.number(), name: z.string() }),
    pick: 'data',
});

const user = await getUser({ params: { id: 1 } }); // typed · validated

保留你已有的 fetch 或 axios——它们是底层适配器。stitch 位于传输层之上，将端点变成函数，而不是取代调用。

动机

几乎每个项目里都有一个 src/api/ 文件夹，里面放着一些轻量函数，用于发起 HTTP 请求并从响应中提取负载。真正让集成可靠的一切——身份验证生命周期、重试、速率限制、超时、响应验证、漂移检测、可观测性——都要在每个调用点重新实现，而且每个封装都会各自逐渐失效。fetch 返回的是不透明的字节，而原始字节并非应用代码（或 AI Agent）所需；两者都需要结构化、经过验证且可观测的结果。

stitch 将所有这些整合回一次调用中：

围绕原始 fetch 手动实现……	……stitch 只需声明一次
不透明的字节，需要自行解析并祈祷格式正确	经过架构验证的类型化结果——每次调用都会捕获漂移
首次失败就抛出异常，后续只能靠你自己	采用退避和抖动的重试，并遵循 Retry-After
一个粗略的超时设置，如果你还记得的话	分层的总超时／单次尝试超时，并可真正中止
没有速率控制——上线后才会遇到 429	主动限流：速率和并发上限，并按主机共享
原始字节流，需要自行分帧和分页	SSE 分帧、增量拼接、自动分页
完全看不出调用做了什么	类型化事件流 + 可选追踪：延迟、重试、漂移

为什么选择 StitchAPI

获取类型化 API 客户端的方式有很多——基于规范的生成器、手写契约客户端、工作流平台，或一组手写的 fetch 包装器。StitchAPI 处于它们都未覆盖的位置：它将一次处理一个端点，转化为具有韧性、经过验证且可观测的函数——无需规范、无需代码生成、无需配置文件、无需服务；只有显式组合。

• 以原子为单位，而非以规范为先。 基于规范的生成器（openapi-generator、Orval、Kubb 等）需要先有完整的 OpenAPI 文档——而大多数真实世界的 API（内部 API、未记录的 API，以及长尾 API）根本没有这类文档。一个 stitch 只需要一个 URL 和一个示例响应。
• 它是运行时，而非代码生成器。 无需提交、比较差异并重新生成 SDK。声明本身_就是_客户端，每次实时调用都会进行验证——因此，字段被悄然重命名时，会发出清晰且分级的漂移信号，而不是在下游三层才出现 undefined。
• 韧性通过声明实现，无需手写。 重试、限流、超时、熔断、分页——都在 stitch 上配置，并在每个集成中保持一致。
• 认证是一条边界。 stitch 自行管理凭证及其生命周期；调用方获取的是能力，而非凭证。当调用方是 AI Agent 时，这一点尤为重要。
• Agent 是一等调用方。 一个定义既是函数，也是 CLI 命令、HTTP 端点和 MCP 工具——返回结构化、经架构验证且可追踪的结果，而非不透明的字节。
• 它是一个库，而非平台。 零运行时依赖，嵌入你的项目，无需运维。

替代方案	需要	你需要维护	StitchAPI 的做法
基于规范的代码生成（openapi-generator、Orval、Kubb 等）	完整的 OpenAPI 规范	生成的 SDK，每次 API 变更时都要重新生成	一次处理一个端点，在运行时进行实时验证
类型化运行时客户端（Zodios、ts-rest 等）	手写契约	围绕它编写自己的重试／认证／速率限制代码	将韧性、认证生命周期和漂移检测内置于基础构件中
工作流平台（Windmill、n8n 等）	要部署的服务	在他人的运行时中维护工作流	零依赖库；组合就是代码
手写的 fetch 包装器	无	每个项目都要重新解决专属认证、重试和限制问题	每个 stitch 只需声明一次相同的事项

如需了解完整的竞争格局和定位，请参阅 概览。

StitchAPI 不是什么

了解一个工具拒绝成为什么，才能信任它真正是什么：

• 不是 HTTP 客户端或 fetch 的替代品——fetch／axios 是底层基础；stitch 位于传输层之上。
• 不是代码生成器——无需提交、比较差异并重新生成 SDK；声明就是运行时，并会进行实时验证。
• 不以规范为先——无需 OpenAPI 文档；一个 URL 和一个示例响应就足够了。
• 不是要部署的服务——这是一个零依赖库，可供你为自己不控制的 API 导入使用。
• 不是工作流引擎或 iPaaS——没有编排、队列或可视化构建器；组合就是纯 TypeScript。
• 没有配置文件或隐式继承——stitch 不会在后台静默读取任何内容。

没有服务，没有代码生成，没有配置文件，没有隐式继承——只有显式组合。

功能

• 一个原语，作用于一个接口面 — stitch(url | config) 会返回一个类型化的可调用对象；包含多个端点的服务是一个 seam，其成员共享 base、auth、throttle budget、store 和 trace sink。
• 事件流核心 — 每次调用都会生成一个类型化流（start → progress → drift → result → done）；await 是语法糖，会返回最终的已验证值。
• 自选验证方案 — Zod 或任何 Standard Schema 验证器（Valibot、ArkType，等等）；类型会根据 schema 推断。
• 分级漂移检测 — 根据声明的 schema（契约）验证实时响应；缺少必需字段或字段不兼容时会抛出错误，而软性漂移（强制转换、未声明字段或默认字段）会作为非致命的 warn / info / verbose 发现项呈现，而不是静默返回 undefined。
• 声明式韧性 — 带退避和 Retry-After 的重试、主动限流、分层超时、断路器和幂等键。
• 读穿缓存 — 可选的响应缓存 + 进程内请求合并，使用派生的、按主体隔离的键，并从 stitchapi/cache 延迟加载。
• 将身份验证作为边界 — bearer、apiKey、basic、cookieSession（自动登录/重新登录）、oauth2；密钥在调用时解析，绝不会传递给调用方。
• 任意请求风格 — 默认使用 http；graphql、sse、stream、download、llm、shell 和 postmessage 都是通过子路径导入提供的同级接口面。
• 可插拔状态存储 — 限流状态、缓存和会话通过带可选原子操作的 get/set 存储管理；可换用 Redis/Postgres 实现分布式运行。
• 零基础设施可观测性 — 默认关闭跟踪；可针对每个 stitch 启用，或通过 STITCH_TRACE_* 环境变量启用。无需收集器，也无需仪表板。
• 四种入口，一个定义 — 进程内函数、CLI（stitch run）、HTTP（stitch serve）和 MCP（stitch mcp）。
• 零运行时依赖 — "dependencies": {}，基于全局 fetch 构建，可进行 tree-shaking；整个入口约 21 kB（min+gzip），典型的 import { stitch } 约 19 kB（缓存引擎和 OTLP 导出器会在首次使用时延迟加载）。

安装

npm install stitchapi@rc   # or: pnpm add stitchapi@rc · yarn add stitchapi@rc

验证方案由你自选 — 传入 Zod schema 或任何 Standard Schema 验证器；不会捆绑任何验证器。下面的示例使用 Zod 以便于理解，并以 api.example.com 作为示例主机 — 可将它们指向你自己的 API 来运行，也可以直接在游乐场中尝试；该游乐场通过浏览器内模拟器提供这个主机。

快速开始

最简单的 stitch 就是一个 URL — 声明一次，多次调用：

import { stitch } from 'stitchapi';

const getUsers = stitch('https://api.example.com/users');

const users = await getUsers(); // GET, parsed JSON

路径参数使用 RFC 6570 URI 模板；params、query、headers 和 body 都通过一个输入对象传递：

const getUser = stitch('https://api.example.com/users/{id}');

await getUser({ params: { id: 1 }, query: { expand: 'roles' } });
// → GET https://api.example.com/users/1?expand=roles

只在需要时才使用全套选项 — 默认情况下它们均处于关闭状态：

const getUser = stitch({
    path: 'https://api.example.com/users/{id}',
    output: User, // a validator of your choice
    pick: 'data',
    retry: 3, // ≡ { attempts: 3 }
    timeout: '5s', // ≡ { total: '5s' }
    cache: '1m', // ≡ { ttl: '1m' }
});

const user = await getUser({ params: { id: 42 } });
// → typed · validated · retried · cached

stitch 会生成一个类型化的事件流；await 会使用该流并返回最终值，而 .safe() 会解析为 { ok, data, error }，.stream() 则会在进度、限流等待、重试和漂移发生时逐一生成相应事件。

组合：seam、extends、.with()

所有可复用内容都是命名值，而 stitch 可以组合这些值 — 不需要任何全局配置。包含多个端点的服务是一个 seam：只需声明一次共享的 base、auth 和 budget；每个端点都是一个成员，会继承配置，并且共享同一个运行时（限流桶、store、trace sink）：

import { seam } from 'stitchapi';

const api = seam({
    baseUrl: 'https://api.example.com',
    retry: { attempts: 3, on: [429, 503] },
    timeout: { total: '30s' },
});

const listUsers = api.stitch({
    path: '/users',
    output: User.array(),
    pick: 'data',
});
const getUser = api.stitch({
    path: '/users/{id}',
    output: User,
    pick: 'data',
});

要实现更轻量的复用，可通过 extends: [fragment | stitch] 从左到右合并配置（自有字段优先），也可通过 .with() 预绑定部分输入，同时复用同一个运行时。完整指南：编写指南。

验证与分级漂移

声明的 output schema 就是契约。用 drift() 包装它：响应会经过验证（调用会返回验证后的值——进行类型强制转换、填入默认值并剔除未知键），原始响应体与验证后值之间的差异则会作为分级的非致命信号报告：

变更	含义	级别
invalid	缺少必填字段或字段不兼容——抛出异常	error
coerced	发生了强制类型转换（"42"→42）：验证隐藏了线上的类型变化	warn
undeclared	被 schema 剔除的键	info
defaulted	触发了 .default()（字段缺失）	verbose

import { drift, stitch } from 'stitchapi';
import { z } from 'zod';

const listOrders = stitch({
    path: 'https://api.example.com/users/{id}/orders',
    pick: 'data',
    output: drift(
        z.array(z.object({ id: z.number(), total: z.number().optional() })),
        {
            ignore: ['[].meta'], // acknowledged, unconsumed — don't report it
            level: { coerced: 'info' }, // re-level a kind, or pass a level/list to filter
        },
    ),
});

漂移以 schema 为锚点——无需管理快照。严重程度由 schema 决定：缺少必填字段或字段不兼容属于硬性 invalid，会抛出异常；其他情况都是事件流中的非致命漂移。已声明的差异（可选字段、可空字段、空数组）都能通过验证，因此不会误报；ignore 会静默处理已知但未消费的字段，而 level 会筛选或重新调整软信号的级别。请求端也会进行验证：input 为每个部分接受一个 schema，并在发送任何请求前快速失败。完整指南：验证与漂移。

弹性：重试、限流、超时

每个 src/api/ 文件夹都会重新实现的功能，都可以在这里统一配置——适用于每个 stitch：

const listUsers = stitch({
    baseUrl: 'https://api.example.com',
    path: '/users',
    retry: { attempts: 4, on: [429, 502, 503] },
    throttle: { rate: '1/s', concurrency: 2, pool: 'host' },
    timeout: { total: '30s', each: '10s' },
});

throttle 是主动限流（在限制生效前让你保持在限额以内；pool: 'host' 可让多个 stitch 共享一个限流器），retry 是被动重试（退避 + Retry-After），timeout 则通过真正的 AbortSignal 中止请求。另外还有三个配置项：circuit 会对已不可用的依赖快速失败，idempotency 会在写入请求中注入稳定的 Idempotency-Key，verdict 则声明成功的判定标准——accept 会将非 2xx 响应（例如 404）作为正常结果，而非抛出异常；flag 会将响应体表明失败的 200 判定为失败。完整指南：弹性。

缓存

支持进程内请求合并的透传式响应缓存——默认关闭，仅当 stitch 设置了 cache 时，才会按需从 stitchapi/cache 加载。缓存键根据已解析的请求派生而来（无需调用方编写缓存键，因此不会产生漂移），并且默认按主体隔离，所以绝不会将用户 A 的缓存响应提供给用户 B：

const getUser = stitch({
    path: 'https://api.example.com/users/{id}',
    output: User,
    pick: 'data',
    cache: '5m',
});

const listAnnouncements = stitch({
    path: 'https://api.example.com/announcements',
    output: z.array(z.object({ id: z.number(), title: z.string() })),
    pick: 'data',
    cache: {
        ttl: '1h',
        tenancy: 'app',
        vary: ['accept-language'],
        entries: 500,
        fingerprint: 1, // pins the shape — cacheable without a fingerprinter
    },
});

缓存从设计上就可靠：带有 output schema 的 stitch，只有在该 schema 可生成指纹或你固定了 fingerprint 标签时才会缓存；否则它会拒绝缓存，而不是提供结构过时的数据。将敏感数据标记为 sensitive: true，即可完全禁用缓存。

将身份验证作为边界

身份验证是 stitch 的一个字段——绝非全局配置。密钥会在调用时解析（env()、credential.file()），声明可以提交到版本控制中，而调用方获取数据时始终无需接触凭据：

import { stitch } from 'stitchapi';
import { bearer, env } from 'stitchapi/auth';

const getUser = stitch({
    path: 'https://api.example.com/users/{id}',
    auth: bearer(env('API_TOKEN')), // resolved per call; the caller passes no secret
});

bearer、apiKey 和 basic 是请求头策略；oauth2() 会执行客户端凭据授权，并缓存／刷新令牌；cookieSession 会执行登录、捕获 Cookie、重放 Cookie，并在会话过期时重新登录——调用方既看不到密码，也不必处理 Cookie 流程。完整指南：身份验证。

使用表面：任意请求风格

使用表面是 stitch 发出的请求_风格_。默认使用 http；其他使用表面都与它并列，运行在同一引擎上——auth、retry、throttle、timeout、验证和事件流都可以与任意一种组合使用。每种使用表面都通过自己的子路径导入，因此 import { stitch } 只会引入 http。

使用表面	导入	形式	await 的解析结果
http	stitch（默认）	JSON-over-HTTP 调用	验证后的正文
graphql	stitchapi/graphql	POST { query, variables }，提取 data	data 负载
sse	stitchapi/sse	text/event-stream 读取器（通过 fetch）	收集到的每个已解析事件
stream	stitchapi/stream	原始 ReadableStream 读取器	收集到的每个已解码数据块
download	stitchapi/download	缓冲式二进制 GET	{ blob, filename }
llm	stitchapi/llm	通过提供方契约进行的聊天补全	规范化的 { text, … }
shell	@stitchapi/shell（对等包）	本地命令、参数和标准输入	命令的标准输出
postmessage	stitchapi/postmessage	类型化的 iframe ↔ parent RPC / 事件调用	类型化的 RPC 响应

完整指南：使用表面。

四种调用入口

同一个类型化单元可以通过四种方式访问，因此人类和 Agent 调用的都是完全相同且经过验证、可观测的对象：

调用入口	方式	示例
进程内函数	导入并调用	await listUsers()
CLI 命令	stitch run	$ stitch run listUsers
HTTP 端点	stitch serve	POST /stitch/listUsers
MCP / Agent 工具	stitch mcp	run_stitch { "name": "listUsers" }

三个非函数入口都通过导出名称访问 stitch；list_stitches 和 GET / 也会列出相同名称。

stitch run 会将每个事件作为一行 JSON 输出到标准输出（可直接交给 jq 处理）；stitch trace 会汇总运行日志，包括运行次数、失败、重试、偏移和延迟百分位数。完整指南：使用表面 → CLI。

原生支持 Agent

stitch 专为 AI Agent 调用而构建。身份验证配置在 stitch 上，因此 Agent 获得的是能力，而非凭据。此外，Agent 不必为每个端点使用一个 MCP 工具（这会塞满模型的上下文），而是通过单个代码模式工具 run_stitch 来操作：它会编写一小段 TypeScript 代码，导入 stitchapi 并调用 stitch；同时还能使用 list_stitches 和 describe_stitch 进行发现——因此，即使目录不断扩展，上下文预算也能保持不变。

创作过程也方便 Agent 使用——给 Agent 一个 curl/HAR/文档示例，它就会生成 stitch 声明，并为常见情况提供确定性的快捷方式：

$ stitch from-curl 'curl https://api.example.com/users/7 -H "authorization: Bearer …"'
# prints a ready-to-commit stitch: id-like segments lifted to {params}, secrets → env()

stitch init 会将“声明一个 stitch，不要手动编写 fetch”这一规则写入编码 Agent 会读取的文件（AGENTS.md、Cursor/Windsurf/Cline 规则以及 CLAUDE.md 中的章节），文档构建还会生成自动生成的 llms.txt。完整指南：在 Agent 中使用。

错误与常见问题

编织失败时会抛出 StitchError——一个 Error 子类，包含 .status、.attempts，以及（针对响应失败）.body（解析后的错误负载，通过非可枚举通道传递，绝不会到达跟踪接收器）和 .url。更倾向于分支处理？.safe() 会解析为 { ok, data, error }。请根据 .status 和 .attempts（以及 instanceof RateLimitError）进行分支判断——下面的 STITCH_* 名称是文档 ID，而非运行时值，因此没有可供匹配的 error.code：

目录 ID	适用情况
STITCH_VALIDATION	响应未通过其输出架构验证
STITCH_DRIFT	响应偏离程度超过了允许的级别
STITCH_AUTH_WALL	身份验证失败，或无法刷新软性 200 登录墙
STITCH_TIMEOUT	调用超出了其超时预算
STITCH_CIRCUIT_OPEN	多次失败后，断路器处于开启状态
STITCH_GRAPHQL	GraphQL 响应返回了 200，但包含 errors 数组
RateLimitError	委托退避编织向外层门控报告了速率限制

完整目录：错误与常见问题。

零基础设施可观测性

可观测性是事件流的使用方，而非独立系统——并且默认关闭。可按每个编织单独启用（trace: 'console' / fileSink(path) / TraceSink），也可通过环境变量全局启用——无需收集器、仪表板，也无需部署任何内容：

STITCH_TRACE_CONSOLE=1 node app.js          # live, colored, one line per event on stderr
STITCH_TRACE_FILE=./run.jsonl node app.js   # append JSONL to a path
STITCH_EXPORT=otlp node app.js              # also fan events to an OTLP collector

内置接收器会在接收器边界清理机密信息（不会触及实时请求）。stitch trace 会汇总 JSONL；@stitchapi/pino 会将相同事件作为结构化日志输出。

软件包

此仓库是一个 pnpm 工作区。发布的库是 stitchapi；其余都是轻量的对等依赖集成，不会增加自身功能。下表由 pnpm gen:readme 自动生成（并由 CI 中的 pnpm check:readme 验证）：它列出所有可发布的工作区软件包，因此随着软件包的添加，内容也不会过时。每个软件包自己的 README 都会链接到 npm 上的对应页面。

包	描述
核心
stitchapi	将任意 API 转化为类型安全且具备弹性的函数
服务端框架
@stitchapi/elysia	在上下文中提供符合 Web 标准的接缝；支持 SSE 和错误映射
@stitchapi/express	在 req 上提供请求级接缝，并支持 SSE 和错误映射
@stitchapi/fastify	提供应用/请求级接缝，支持 SSE、错误和 Pino 日志记录器桥接
@stitchapi/hono	在请求上下文中提供适用于边缘环境的接缝；支持 SSE 和错误处理
@stitchapi/nest	可注入的 stitch，接入 Nest DI 图
@stitchapi/next	在 App Router 中将 stitch 作为 SSE Response 流式传输
客户端和 UI 绑定
@stitchapi/angular	将 Stitch 生命周期封装为 Angular signals 和 RxJS observable
@stitchapi/expo	通过 expo/fetch 流式传输，并使用 secure-store token 存储
@stitchapi/query-core	为 UI 绑定提供与框架无关的响应式存储
@stitchapi/react	避免 tearing 的 useStitch / useStitchStream hooks
@stitchapi/react-native	流式 XHR 适配器和基于 AsyncStorage 的存储
@stitchapi/solid	将 createStitch 原语协调至 Solid 存储中
@stitchapi/svelte	适用于 Svelte 4 和 5 的 Stitch 存储（单次请求 + 流式传输）
@stitchapi/vue	响应式 useStitch / useStitchStream 组合式函数
数据获取库
@stitchapi/rtk-query	将 stitch 作为 RTK Query 端点运行，并支持流式更新
@stitchapi/swr	将 stitch 作为 SWR fetcher 运行；缓存由 SWR 管理
状态存储
@stitchapi/cloudflare-kv	基于 Workers KV 的边缘缓存和共享会话
@stitchapi/deno-kv	基于 Deno KV 的分布式限流和会话
@stitchapi/redis	通过 Redis 实现分布式限流和共享会话
身份验证
@stitchapi/aws-sigv4	使用 AWS SigV4 对请求签名（适用于边缘环境的 Web Crypto）
AI
@stitchapi/vercel-ai	将 stitch 暴露为可由模型调用的工具，并安全处理凭据
可观测性
@stitchapi/pino	将 stitch 事件流记录为结构化 Pino 日志
@stitchapi/sentry	将 Stitch 事件记录为 Sentry 面包屑，并捕获错误
接口
@stitchapi/shell	将静态本地命令作为 stitch 运行（可防止注入）
缓存指纹适配器
@stitchapi/fingerprint-arktype	适用于 ArkType 架构的缓存指纹策略
@stitchapi/fingerprint-effect	适用于 Effect Schema 的缓存指纹策略
@stitchapi/fingerprint-typebox	适用于 TypeBox 架构的缓存指纹策略
@stitchapi/fingerprint-valibot	适用于 Valibot 架构的缓存指纹策略
@stitchapi/fingerprint-zod	适用于 Zod 架构的缓存指纹策略
其他
@stitchapi/docs-mcp	StitchAPI 文档搜索，通过 MCP stdio 在本地运行
@stitchapi/json-schema	将运行时发现的 JSON Schema 转换为 StitchAPI 可接受的 Standard Schema 验证器
@stitchapi/openapi	从 OpenAPI 文档中提取选定操作，生成可直接接手维护的 StitchAPI 源码

## 文档

完整文档网站位于 stitchapi.dev — 快速入门、按功能分类的指南、概念、接口、面向 Agent，以及生成的参考文档。

已发布库自身的 README（npm 展示的内容）位于 packages/core/README.md。设计说明位于 docs/：功能透镜、概览、设计。

贡献

本地设置、开发循环、包体积预算，以及 worktree + PR 工作流均记录在 CONTRIBUTING.md 中。

许可证

Apache-2.0