@seanyao/roll 4.714.2 → 4.718.2

package/guide/zh/faq.md

@@ -557,6 +557,46 @@ roll loop reset
 更细的操作话题（pause/resume、切换 agent、gh scope 等）见
 [loop.md](loop.md) 和 [configuration.md](configuration.md)。
 
+### C5b. `roll loop on` 报 launchd bootstrap 错误怎么办？
+
+**简答：** 此时排程未激活。优先修复 launchd；实在修不好再使用 owner
+明示确认的进程 fallback。
+
+**原因：** macOS launchd 有时会以 `Bootstrap failed: 5: Input/output error`
+（或类似域错误）拒绝 bootstrap。Roll 会重试一次、用 `launchctl print`
+验证挂载，若仍失败就以非零码退出，不会假装调度器已启用。
+
+**先修 launchd：**
+
+```bash
+UID=$(id -u)
+LABEL=$(launchctl list | awk '$3 ~ /^com\.roll\.loop\./ {print $3; exit}')
+# 如果 launchctl list 没有输出，请使用错误信息里的精确 label。
+launchctl bootout gui/$UID/$LABEL
+launchctl bootstrap gui/$UID ~/Library/LaunchAgents/$LABEL.plist
+launchctl print gui/$UID/$LABEL
+roll loop on
+roll loop status
+```
+
+**如果 launchd 无法修复：**
+
+```bash
+roll loop fallback start --confirm
+roll loop fallback status
+```
+
+fallback 不是 launchd 的等价替代，不会跨过重启/登出。重启或重新登录后
+必须重新确认：
+
+```bash
+roll loop fallback stop
+roll loop fallback start --confirm
+```
+
+脱敏、无需 root 的现场验证流程见
+[从 launchd bootstrap 失败中恢复](loop.md#从-launchd-bootstrap-失败中恢复)。
+
 ### C7. 改了 loop_schedule 但 loop 还是按旧频次跑
 
 **症状：** 更新了 `.roll/local.yaml` 的 `loop_schedule`，但 `roll loop status`
@@ -772,3 +812,59 @@ gh issue create --title "Safari 上登录失败" --body "复现步骤: ..."
 这些控制只影响用户可见表面。Agent 契约、代码、git 元数据和 schema 保持英文；
 与 owner 的对话跟随当前任务里 owner 使用的语言。发版前可运行
 `roll doctor language` 审计文档、约定、skills 与生成表面的语言漂移。
+
+### C12. `roll browser interactive` 有什么限制？
+
+**短答：** 它是一个面向本地 Chrome 调试端点的前台、owner 运行、单次操作工具——
+不是后台自动化，也不是远程浏览器。
+
+**细节：** `roll browser interactive` 要求：
+
+- 已连接的 TTY 和每次操作的显式 owner 批准。
+- 你自己用 loopback 调试端口启动的 Chrome，例如 `127.0.0.1` 上的
+  `--remote-debugging-port=9222`。
+
+它**永远不会**：
+
+- 从后台调度器或 CI 作业中运行。
+- 连接远程或非 loopback 端点。
+- 导出 cookie、storage 或 network bodies。
+- 自动启动 Chrome。
+- 独自让 CI 通过——结果仅用于 **owner-run manual-attest**。
+
+租约最多 15 分钟，操作结束后立即释放。无人值守诊断请用受管通道
+（`roll browser run`）。
+
+### C13. 某个故事被标记为证据降级——需要重建吗？
+
+**简答：** 不需要。`degraded-infrastructure` 表示代码交付已通过，只是截图机器
+出了故障（宿主 / 供应方 / 工具）。重建故事解决不了任何问题。只修复证据即可：
+
+```bash
+roll capture repair <story-id>
+```
+
+**细节：** `roll capture repair` **只**重跑截图通道并重新解析证据健康，绝不重开
+构建或 TCR 周期，交付结论原样带过。对失败交付或任何非降级状态，它会拒绝（同样
+不重建）。
+
+先查清截图为何不可用：
+
+```bash
+roll doctor                 # “Capture policy readiness / 截图策略就绪度” 一节
+roll capture status         # 网关 + 渲染器就绪度与有效策略
+roll loop status --capture
+```
+
+若 v2 网关显示 `provider_v2_unavailable`，请安装/更新 Roll Capture.app 使其
+advertise `roll.capture.v2`；若渲染器不可用，运行 `npx playwright install
+chromium`。视觉 AC 由 **Roll Capture · physical** 图像或绑定目标的
+**Playwright · rendered** 回执任一满足——当渲染回执已绑定该目标面时，并不要求
+必须有物理图像。
+
+### C14. `roll capture migrate` 显示 “retained”——为什么没启用 best_effort？
+
+迁移是能力感知的，绝不猜测。只有在 v2 网关**和**渲染器**都**就绪时才启用
+`best_effort`；否则保留既有策略并给出显式原因：`provider_v2_unavailable`（截图
+宿主未 advertise v2）或 `renderer_unavailable`（未安装 Playwright Chromium）。
+修好所报能力后重跑即可——迁移是幂等的，`roll capture migrate --revert` 可回退。

package/guide/zh/loop.md

@@ -31,7 +31,7 @@ Loop 在名为 **`roll-loop-<project-slug>`** 的 **tmux session** 里运行。
 
 | 指标 | 目标 | 防应试口径 | `null` 含义 |
 |------|------|------------|-------------|
-| 自主运行时长 | ≥72 小时 | 有效自主日需要至少 6 次非 idle 尝试；backlog 空的日期只停表，不计为未达标时间。 | 暂无足够合格运行历史，或窗口内 backlog 为空。 |
+| 自主运行时长 | ≥72 小时 | `current` 是声明的 14 天窗口内合格每日小时之和，而不是最近一段未中断时长。有效自主日需要至少 6 次非 idle 尝试；backlog 空的日期只停表，不计为未达标时间。 | 暂无足够合格运行历史，或窗口内 backlog 为空。 |
 | 交付率 | ≥60% | 交付按 merge truth 统计，不按 cycle 自报退出码。 | 暂无可作为分母的交付样本。 |
 | 修复税 | <1x | 分母仅统计 US 卡；FIX 工作不能改善自己的比值。 | 窗口内没有 US 卡分母。 |
 | 归因错误 | =0 | `unknown` 不猜成 env、harness 或 card；缺失 envelope 保持可见。 | 暂无归因样本。 |
@@ -97,6 +97,77 @@ Loop 通过 **launchd**（macOS）调度。默认每小时在一个根据项目
 验证任务确实存活。如果 launchd 仍拒绝任务，命令会以非零码退出，并打印准确的
 域、标签、plist 路径和可直接执行的诊断命令；bootstrap 失败不会再伪装成已启用。
 
+### 从 launchd bootstrap 失败中恢复
+
+`roll loop on` 失败后，排程处于**未激活**状态。`~/Library/LaunchAgents/`
+里的 plist 文件存在并**不**代表自主排程已启用——只有 `launchctl list`
+显示对应 label 已加载，loop 才是真正就绪的。请用 `roll loop status` 查看
+当前生效后端（`launchd`、`process-fallback` 或 `none`）。
+
+**优先修复 launchd。** 错误输出已经打印了精确命令，通用形式使用
+`launchctl list` 返回的 label：
+
+```bash
+UID=$(id -u)
+LABEL=$(launchctl list | awk '$3 ~ /^com\.roll\.loop\./ {print $3; exit}')
+# 如果 launchctl list 没有输出，请使用 roll loop on 错误信息里的精确 label。
+launchctl bootout gui/$UID/$LABEL
+launchctl bootstrap gui/$UID ~/Library/LaunchAgents/$LABEL.plist
+launchctl print gui/$UID/$LABEL
+roll loop status
+```
+
+如果 `launchctl bootstrap` 成功且 `print` 显示任务存活，再次运行
+`roll loop on` 以重新生成当前 runner 并确认调度。
+
+**如果 launchd 实在无法修复**，Roll 提供一个需要 owner 明示确认的进程
+fallback，只有显式确认时才会启动：
+
+```bash
+roll loop fallback start --confirm
+roll loop fallback status
+roll loop fallback stop        # 不再需要时停止
+```
+
+该 fallback **不是** launchd 的等价替代：它不会跨过重启或登出会话。
+重启或重新登录后，必须先停止旧 lease 再重新确认：
+
+```bash
+roll loop fallback stop
+roll loop fallback start --confirm
+```
+
+优先修复 launchd；仅在 launchd 不可用时使用 fallback。
+
+#### macOS 现场验证流程（Bootstrap failed: 5）
+
+当 `roll loop on` 报 `Bootstrap failed: 5: Input/output error` 这类错误时，
+记录一份已脱敏、无需 root 的诊断包：
+
+```bash
+mkdir -p .roll/loop
+TS=$(date +%Y%m%d-%H%M%S)
+OUT=.roll/loop/launchd-verify-$TS.log
+{
+  echo "roll version: $(roll version)"
+  echo "uid: $(id -u)"
+  echo "---"
+  echo "roll loop status:"
+  roll loop status
+  echo "---"
+  echo "launchctl list（roll lane）:"
+  launchctl list | grep com.roll\. || true
+  echo "---"
+  echo "磁盘上的 plist:"
+  ls -1 ~/Library/LaunchAgents/com.roll.loop.*.plist 2>/dev/null || true
+} > "$OUT"
+# 分享前脱敏：把真实 home 路径替换为 ~。
+sed -i.bak "s|$HOME|~|g" "$OUT" && rm -f "$OUT".bak
+```
+
+该流程只使用用户级（`gui/<uid>`）launchctl 命令，不需要 `sudo`，也不依赖
+`launchctl dumpstate` 等仅限 root 的诊断。
+
 ## 配置调度（Configuring the schedule）
 
 不用再手工编辑 `~/.roll/config.yaml` 和 `.roll/local.yaml` 再祈祷 launchd plist 能 reload 上。改用 `roll config` 命令族：每次写入都落到正确的 yaml 文件，**并且**自动重生 runner、重 bootstrap launchd plist、立刻在 `roll loop status` 反映——没有手工 reload 这一步。
@@ -235,7 +306,7 @@ roll loop gc --keep-days 14   # 覆盖保留天数（也可用 .roll/local.yaml
 roll loop events      # 显示最近 20 条 cycle 事件
 roll loop events 50   # 显示最近 50 条
 
-roll agent                           # 查看 scope、role、agent pool 与 legacy 输入
+roll agent                           # 查看 scope、有效项目能力与 agent pool
 roll agent list                      # 查看本机已装的 agent
 ```
 
@@ -275,8 +346,10 @@ paused 状态时不建议直接启动：`PAUSE-<slug>` 标记仍会在 cycle 边
 预算与运行上限每次 `roll loop go` 都是显式的。`--budget`、`--max-cycles`、`--for`
 只对本次调用生效；省略某项即代表本轮不设该限制——Roll 绝不从上一次会话持久化的
 goal 静默沿用预算或上限，因此一条不带 flag 的 `roll loop go` 既不会被几天前设的
-上限封顶，也不会被它卡死。范围（`--epic`/`--cards`）与 `--review` 在省略时仍沿用，
-因为它们是 goal 的身份，而不是每次运行的安全旋钮。
+上限封顶，也不会被它卡死。范围（`--epic`/`--cards`）与 `--review` 只会在 goal 尚未
+结束时于省略 flag 后沿用。goal 已 `complete` 时，下一次 `roll loop go` 会将它归档到
+`.roll/loop/goal-archive/`、记录 `goal:archived`，并完全按本次 flags 新建 goal；不带
+scope flag 则覆盖全部合格 backlog 卡，绝不会静默沿用已完成 goal 的范围。
 
 `roll loop go` 的安全闸只在 cycle 边界生效。`--budget <usd>` 使用有效成本账本；
 达到预算时 goal 进入 `budget_limited`。未执行 agent 的 idle 或 aborted 周期记为
@@ -286,11 +359,27 @@ unknown，这类行仍按保守侧停止，不当作 0。用量闸检查 5 小
 不会让会话无限停摆；超时后 Roll 记录 `usage_wait_timeout` 审计事件并让 goal 保持暂停。
 `--for <duration>` 是墙钟时间盒：当前 cycle 收尾后，goal 以 `timebox` 原因暂停。
 
-启动第一个 builder cycle 前，`roll loop go` 还会兜底检查遗留未提交的 Roll bootstrap 产物，
-例如 `AGENTS.md`、`.claude/` 或 `.roll/` 元数据。新版 `roll init` 应该已经把这些
-Roll-owned 文件提交并推送；如果历史版本或手工路径仍然只留下这些脏文件，goal 会以
-`bootstrap_artifacts_unconfirmed` 暂停，并打印待确认文件。提交或清理后，再重新运行
-`roll loop go`。这个 preflight 不会启动 cycle，也不会累加 no-progress。
+每个 builder cycle 前，`roll loop go` 会对主 checkout 的**完整** `git status`
+列表（绝不截断）与 runner 的**待交付证据 manifest** 逐条比对。每个 manifest 按 cycle
+记录一个仍在开启的交付 PR 的确切证据路径及其 SHA-256 哈希，原子写入
+`.roll/loop/evidence-manifests/`。
+
+- **verified（已核实）**——当前内容哈希命中某个 manifest 记录的 `.roll/**` 文件。
+  它们是 runner 生成的产物（开启 PR 的 dossier、报告、截图），会发出
+  `bootstrap_artifacts_verified`，绝不会暂停一张无关的可执行卡。
+- **unconfirmed（未确认）**——其余任何 `.roll/**` 文件（未知路径、哈希不匹配、
+  manifest 损坏/过期、symlink 逃逸或目录）。
+- **external（外部）**——任何非 `.roll/**`（产品文件）脏改动。
+
+如果脏改动只有 verified 证据，preflight 直接放行；如果只剩 unconfirmed 的 `.roll`
+污染，goal 以 `bootstrap_artifacts_unconfirmed` 暂停并打印确切文件（verified 证据不会
+被列出），便于你确认归属：提交到产品仓或 `.roll/roll-meta`、按策略 ignore、或清理后
+重跑。产品文件脏改动会被显式暴露（不再被隐藏），交给 cycle 处理。这个 preflight 不会
+启动 cycle，也不会累加 no-progress。
+
+放行只认 manifest + 哈希：设计上**没有** `--ignore-dirty` 或“trust all evidence”
+绕过开关。泛泛的 `.roll/**` 路径或很长的 status 列表都无法让闸变宽松；凡是 runner 没有
+记录且当前哈希不匹配的，一律 fail closed。
 
 在 Roll 仓自身里，`roll loop go`、`roll loop resume` 和 `roll loop now`
 开工前都会打印当前 runner 的 binary 与版本。repo-local `@seanyao/roll`
@@ -365,9 +454,11 @@ defaults:
         strategy: health-aware
 ```
 
-`roll agent` 会显示 Machine Scope、Project Scope、已解析角色、候选池、运行时健康说明，
-以及 legacy compatibility 输入。用 `roll agent migrate --dry-run` 预览旧 agent
-文件迁移。
+`roll agent` 会显示 Machine Scope 和有效 Project Scope，包括继承后的 agent 与已配置的
+route model；它不会预测下一次角色分配。dispatch 会在 spawn 时依据运行时健康和
+least-recent 状态决策。需要诊断快照时使用
+`roll supervisor route --role builder|evaluator`。用 `roll agent migrate --dry-run`
+预览一次性迁移；正常执行不会读取旧 agent 配置。
 
 运行时健康不是静态策略。quota、auth、网络、VPN、账号、stall 或 binary 缺失只会
 挂起运行态 rig，并记录为运行时事实；Roll 不回写 `agents.yaml`。挂起 rig 按恢复窗口
@@ -564,6 +655,10 @@ Gate 或 owner 需要介入，因为普通接力没有干净完成。`terminus`
 
 `roll loop status` 输出一个紧凑的仪表盘，包含每个 cycle 的行记录和每日汇总。
 
+当当前所有可派工卡都需要物理终端截图且 macOS 已锁屏时，状态行会显示“等待屏幕解锁”。
+这属于等待态，不是 idle 失败：下一次探测到解锁的 tick 会清除提示并正常派工，且不会消耗
+no-progress 熔断次数。
+
 ### Token 列
 
 每条 cycle 行的 token 用量以 4 分量格式显示：
@@ -1270,3 +1365,7 @@ Since Phase 2.0, loop state lives inside the project at `<project>/.roll/loop/`.
 plist——旧版本退役的形态(ci/alert/brief)曾以僵尸身份指着已删除的引擎存活数周。
 `roll doctor` 列出本机全部 `com.roll.*` 任务及其目标目录与加载状态;目标目录
 已不存在的 lane 标红 STALE。
+
+bootstrap 失败后留在磁盘上的 plist，或者手动 `bootout` 后残留的 plist，
+**不**等于 loop 已激活。请始终依据 `roll loop status`（有效后端）和
+`launchctl list` 来判断，而不是仅看 `.plist` 文件是否存在。

package/guide/zh/pairing.md

@@ -15,7 +15,7 @@ Roll 把评审指派看成 scoped Agent 模型里的 `evaluate` 角色：
 
 ```bash
 roll agent                         # 查看 story.evaluate
-roll agent migrate --dry-run       # 如有旧 pairing.yaml，预览迁移
+roll agent migrate --dry-run       # 预览旧 agent 配置的一次性迁移
 ```
 
 新项目应在 `.roll/agents.yaml` 里声明 evaluator pool：
@@ -34,9 +34,8 @@ defaults:
         strategy: health-aware
 ```
 
-`.roll/pairing.yaml` 仍是 legacy compatibility 输入；两者同时存在时优先使用 scoped
-`evaluate` role。静态配置列公平候选，auth/network/VPN/account 等运行时失败只在本次
-resolution 中跳过候选。
+`.roll/pairing.yaml` 不再是运行时输入；scoped `evaluate` role 是结对候选的唯一来源。
+静态配置列公平候选，auth/network/VPN/account 等运行时失败只在本次 resolution 中跳过候选。
 
 ## 看它做了什么 —— 可观测性
 

package/guide/zh/testing.md

@@ -70,6 +70,24 @@ pnpm test:cov           # 全套 + v8 覆盖率
 通过证明（见下）。纯文档改动无受影响测试，exit 0。pre-push / CI / release
 一律跑全套 `pnpm -r test`。
 
+### 运行器兼容性与保守回退
+
+`roll test` 从**目标项目**解析闸命令，而不是假定某一个固定 flag，因此始终与
+项目里已安装的测试运行器兼容（FIX-1274）：
+
+- Roll 自己的 wrapper 继续用 `--affected`。
+- 普通 Vitest 项目改用该版本支持的 `--changed` changed-test 模式。Roll 绝不把
+  `--affected` 传给 Vitest——Vitest CLI 会把它当未知选项拒绝，否则会卡死提交。
+- 当无法确认安全的 changed 模式（Vitest 版本探测不到/过旧、非 Vitest 运行器），
+  或 `--changed` 匹配到**零个**测试时，roll 改跑项目的**全量**测试命令。回退永远
+  比 affected 闸**更严格**——绝不放过部分或空测试。
+
+**证明保证**：`.roll/last-test-pass` **只在**受支持的命令真正执行且返回 0 后写入，
+记录被测树哈希、实际执行的命令、所选模式和时间戳。失败、未知选项、零测试的运行
+都不会生成证明，因此一份证明永远代表一次真实的绿色测试运行，且绑定到确切的提交树。
+无法解析的项目（`package.json` 没有 `scripts.test`）会带结构化诊断和安全的下一步
+明确报错，而不是静默通过。
+
 ## 测试质量评分卷（rubric）
 
 `guide/zh/testing/quality-rubric.md`（由 `$roll-.dream` Scan 7 消费）列出

package/guide/zh/tools.md

@@ -79,6 +79,17 @@ tools:
 
 未知字段会告警但不会拒绝整个 policy 文件，方便新旧版本之间前向兼容。
 
+## Owner Chrome：手动交互通道
+
+`roll browser interactive` 是一次性的、owner 手动运行边界：它只会连接已经开启的 loopback Chrome DevTools 端点，执行一个 typed 低风险动作。每次运行都必须附着 TTY，并重新输入 `y` 批准；提示会列出故事、批准的 origin、动作摘要、最长 15 分钟的过期时间和“禁止凭据导出”。
+
+```text
+roll browser interactive --story US-BROW-008b --origin https://app.example.test \
+  --action navigate --url https://app.example.test/account
+```
+
+它只连接 origin 与 `--origin` 匹配的 tab，并会在批准过期、取消、错误或进程退出时断开 DevTools。Roll 不会启动或关闭 owner 的 Chrome。封闭动作词表只有 `navigate`、`click`、`fill` 和 `press_key`；cookie、storage 和 network body 没有 CLI 或 adapter 表面。交互成功只是手动证据，不会让 CI 通过，也不会变成后台自动化。
+
 ## CLI
 
 用 `roll doctor tools status` 查看当前项目已注册工具、输入契约、依赖就绪度和合成后的有效 policy 状态。

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jason Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/README.md

@@ -0,0 +1,205 @@
+<p align="center">
+  <img src="https://i.imgur.com/BqsX9NT.png" width="300" height="300" alt="mitt">
+  <br>
+  <a href="https://www.npmjs.org/package/mitt"><img src="https://img.shields.io/npm/v/mitt.svg" alt="npm"></a>
+  <img src="https://github.com/developit/mitt/workflows/CI/badge.svg" alt="build status">
+  <a href="https://unpkg.com/mitt/dist/mitt.js"><img src="https://img.badgesize.io/https://unpkg.com/mitt/dist/mitt.js?compression=gzip" alt="gzip size"></a>
+</p>
+
+# Mitt
+
+> Tiny 200b functional event emitter / pubsub.
+
+-   **Microscopic:** weighs less than 200 bytes gzipped
+-   **Useful:** a wildcard `"*"` event type listens to all events
+-   **Familiar:** same names & ideas as [Node's EventEmitter](https://nodejs.org/api/events.html#events_class_eventemitter)
+-   **Functional:** methods don't rely on `this`
+-   **Great Name:** somehow [mitt](https://npm.im/mitt) wasn't taken
+
+Mitt was made for the browser, but works in any JavaScript runtime. It has no dependencies and supports IE9+.
+
+## Table of Contents
+
+-   [Install](#install)
+-   [Usage](#usage)
+-   [Examples & Demos](#examples--demos)
+-   [API](#api)
+-   [Contribute](#contribute)
+-   [License](#license)
+
+## Install
+
+This project uses [node](http://nodejs.org) and [npm](https://npmjs.com). Go check them out if you don't have them locally installed.
+
+```sh
+$ npm install --save mitt
+```
+
+Then with a module bundler like [rollup](http://rollupjs.org/) or [webpack](https://webpack.js.org/), use as you would anything else:
+
+```javascript
+// using ES6 modules
+import mitt from 'mitt'
+
+// using CommonJS modules
+var mitt = require('mitt')
+```
+
+The [UMD](https://github.com/umdjs/umd) build is also available on [unpkg](https://unpkg.com):
+
+```html
+<script src="https://unpkg.com/mitt/dist/mitt.umd.js"></script>
+```
+
+You can find the library on `window.mitt`.
+
+## Usage
+
+```js
+import mitt from 'mitt'
+
+const emitter = mitt()
+
+// listen to an event
+emitter.on('foo', e => console.log('foo', e) )
+
+// listen to all events
+emitter.on('*', (type, e) => console.log(type, e) )
+
+// fire an event
+emitter.emit('foo', { a: 'b' })
+
+// clearing all events
+emitter.all.clear()
+
+// working with handler references:
+function onFoo() {}
+emitter.on('foo', onFoo)   // listen
+emitter.off('foo', onFoo)  // unlisten
+```
+
+### Typescript
+
+Set `"strict": true` in your tsconfig.json to get improved type inference for `mitt` instance methods.
+
+```ts
+import mitt from 'mitt';
+
+type Events = {
+  foo: string;
+  bar?: number;
+};
+
+const emitter = mitt<Events>(); // inferred as Emitter<Events>
+
+emitter.on('foo', (e) => {}); // 'e' has inferred type 'string'
+
+emitter.emit('foo', 42); // Error: Argument of type 'number' is not assignable to parameter of type 'string'. (2345)
+```
+
+Alternatively, you can use the provided `Emitter` type:
+
+```ts
+import mitt, { Emitter } from 'mitt';
+
+type Events = {
+  foo: string;
+  bar?: number;
+};
+
+const emitter: Emitter<Events> = mitt<Events>();
+```
+
+## Examples & Demos
+
+<a href="http://codepen.io/developit/pen/rjMEwW?editors=0110">
+  <b>Preact + Mitt Codepen Demo</b>
+  <br>
+  <img src="https://i.imgur.com/CjBgOfJ.png" width="278" alt="preact + mitt preview">
+</a>
+
+* * *
+
+## API
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+#### Table of Contents
+
+-   [mitt](#mitt)
+-   [all](#all)
+-   [on](#on)
+    -   [Parameters](#parameters)
+-   [off](#off)
+    -   [Parameters](#parameters-1)
+-   [emit](#emit)
+    -   [Parameters](#parameters-2)
+
+### mitt
+
+Mitt: Tiny (~200b) functional event emitter / pubsub.
+
+Returns **Mitt** 
+
+### all
+
+A Map of event names to registered handler functions.
+
+### on
+
+Register an event handler for the given type.
+
+#### Parameters
+
+-   `type` **([string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String) \| [symbol](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Symbol))** Type of event to listen for, or `'*'` for all events
+-   `handler` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** Function to call in response to given event
+
+### off
+
+Remove an event handler for the given type.
+If `handler` is omitted, all handlers of the given type are removed.
+
+#### Parameters
+
+-   `type` **([string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String) \| [symbol](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Symbol))** Type of event to unregister `handler` from, or `'*'`
+-   `handler` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)?** Handler function to remove
+
+### emit
+
+Invoke all handlers for the given type.
+If present, `'*'` handlers are invoked after type-matched handlers.
+
+Note: Manually firing '\*' handlers is not supported.
+
+#### Parameters
+
+-   `type` **([string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String) \| [symbol](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Symbol))** The event type to invoke
+-   `evt` **Any?** Any value (object is recommended and powerful), passed to each handler
+
+## Contribute
+
+First off, thanks for taking the time to contribute!
+Now, take a moment to be sure your contributions make sense to everyone else.
+
+### Reporting Issues
+
+Found a problem? Want a new feature? First of all see if your issue or idea has [already been reported](../../issues).
+If don't, just open a [new clear and descriptive issue](../../issues/new).
+
+### Submitting pull requests
+
+Pull requests are the greatest contributions, so be sure they are focused in scope, and do avoid unrelated commits.
+
+-   Fork it!
+-   Clone your fork: `git clone https://github.com/<your-username>/mitt`
+-   Navigate to the newly cloned directory: `cd mitt`
+-   Create a new branch for the new feature: `git checkout -b my-new-feature`
+-   Install the tools necessary for development: `npm install`
+-   Make your changes.
+-   Commit your changes: `git commit -am 'Add some feature'`
+-   Push to the branch: `git push origin my-new-feature`
+-   Submit a pull request with full remarks documenting your changes.
+
+## License
+
+[MIT License](https://opensource.org/licenses/MIT) © [Jason Miller](https://jasonformat.com/)

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/dist/mitt.js

@@ -0,0 +1,2 @@
+module.exports=function(n){return{all:n=n||new Map,on:function(e,t){var i=n.get(e);i?i.push(t):n.set(e,[t])},off:function(e,t){var i=n.get(e);i&&(t?i.splice(i.indexOf(t)>>>0,1):n.set(e,[]))},emit:function(e,t){var i=n.get(e);i&&i.slice().map(function(n){n(t)}),(i=n.get("*"))&&i.slice().map(function(n){n(e,t)})}}};
+//# sourceMappingURL=mitt.js.map

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/dist/mitt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mitt.js","sources":["../src/index.ts"],"sourcesContent":["export type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n\ttype: keyof T,\n\tevent: T[keyof T]\n) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<\n\tWildcardHandler<T>\n>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n\tkeyof Events | '*',\n\tEventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n\tall: EventHandlerMap<Events>;\n\n\ton<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n\ton(type: '*', handler: WildcardHandler<Events>): void;\n\n\toff<Key extends keyof Events>(\n\t\ttype: Key,\n\t\thandler?: Handler<Events[Key]>\n\t): void;\n\toff(type: '*', handler: WildcardHandler<Events>): void;\n\n\temit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n\temit<Key extends keyof Events>(\n\t\ttype: undefined extends Events[Key] ? Key : never\n\t): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n\tall?: EventHandlerMap<Events>\n): Emitter<Events> {\n\ttype GenericEventHandler =\n\t\t| Handler<Events[keyof Events]>\n\t\t| WildcardHandler<Events>;\n\tall = all || new Map();\n\n\treturn {\n\t\t/**\n\t\t * A Map of event names to registered handler functions.\n\t\t */\n\t\tall,\n\n\t\t/**\n\t\t * Register an event handler for the given type.\n\t\t * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n\t\t * @param {Function} handler Function to call in response to given event\n\t\t * @memberOf mitt\n\t\t */\n\t\ton<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\thandlers.push(handler);\n\t\t\t} else {\n\t\t\t\tall!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Remove an event handler for the given type.\n\t\t * If `handler` is omitted, all handlers of the given type are removed.\n\t\t * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n\t\t * @param {Function} [handler] Handler function to remove\n\t\t * @memberOf mitt\n\t\t */\n\t\toff<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\tif (handler) {\n\t\t\t\t\thandlers.splice(handlers.indexOf(handler) >>> 0, 1);\n\t\t\t\t} else {\n\t\t\t\t\tall!.set(type, []);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Invoke all handlers for the given type.\n\t\t * If present, `'*'` handlers are invoked after type-matched handlers.\n\t\t *\n\t\t * Note: Manually firing '*' handlers is not supported.\n\t\t *\n\t\t * @param {string|symbol} type The event type to invoke\n\t\t * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n\t\t * @memberOf mitt\n\t\t */\n\t\temit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n\t\t\tlet handlers = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as EventHandlerList<Events[keyof Events]>)\n\t\t\t\t\t.slice()\n\t\t\t\t\t.map((handler) => {\n\t\t\t\t\t\thandler(evt!);\n\t\t\t\t\t});\n\t\t\t}\n\n\t\t\thandlers = all!.get('*');\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as WildCardEventHandlerList<Events>)\n\t\t\t\t\t.slice()\n\t\t\t\t\t.map((handler) => {\n\t\t\t\t\t\thandler(type, evt!);\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t};\n}\n"],"names":["all","Map","on","type","handler","handlers","get","push","set","off","splice","indexOf","emit","evt","slice","map"],"mappings":"wBA8CCA,GAOA,MAAO,CAINA,IANDA,EAAMA,GAAO,IAAIC,IAchBC,YAA6BC,EAAWC,GACvC,IAAMC,EAAmDL,EAAKM,IAAIH,GAC9DE,EACHA,EAASE,KAAKH,GAEdJ,EAAKQ,IAAIL,EAAM,CAACC,KAWlBK,aAA8BN,EAAWC,GACxC,IAAMC,EAAmDL,EAAKM,IAAIH,GAC9DE,IACCD,EACHC,EAASK,OAAOL,EAASM,QAAQP,KAAa,EAAG,GAEjDJ,EAAKQ,IAAIL,EAAM,MAelBS,cAA+BT,EAAWU,GACzC,IAAIR,EAAWL,EAAKM,IAAIH,GACpBE,GACFA,EACCS,QACAC,IAAI,SAACX,GACLA,EAAQS,MAIXR,EAAWL,EAAKM,IAAI,OAElBD,EACCS,QACAC,IAAI,SAACX,GACLA,EAAQD,EAAMU"}

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/dist/mitt.mjs

@@ -0,0 +1,2 @@
+export default function(n){return{all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e])},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]))},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e)}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e)})}}}
+//# sourceMappingURL=mitt.mjs.map

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/dist/mitt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mitt.mjs","sources":["../src/index.ts"],"sourcesContent":["export type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n\ttype: keyof T,\n\tevent: T[keyof T]\n) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<\n\tWildcardHandler<T>\n>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n\tkeyof Events | '*',\n\tEventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n\tall: EventHandlerMap<Events>;\n\n\ton<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n\ton(type: '*', handler: WildcardHandler<Events>): void;\n\n\toff<Key extends keyof Events>(\n\t\ttype: Key,\n\t\thandler?: Handler<Events[Key]>\n\t): void;\n\toff(type: '*', handler: WildcardHandler<Events>): void;\n\n\temit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n\temit<Key extends keyof Events>(\n\t\ttype: undefined extends Events[Key] ? Key : never\n\t): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n\tall?: EventHandlerMap<Events>\n): Emitter<Events> {\n\ttype GenericEventHandler =\n\t\t| Handler<Events[keyof Events]>\n\t\t| WildcardHandler<Events>;\n\tall = all || new Map();\n\n\treturn {\n\t\t/**\n\t\t * A Map of event names to registered handler functions.\n\t\t */\n\t\tall,\n\n\t\t/**\n\t\t * Register an event handler for the given type.\n\t\t * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n\t\t * @param {Function} handler Function to call in response to given event\n\t\t * @memberOf mitt\n\t\t */\n\t\ton<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\thandlers.push(handler);\n\t\t\t} else {\n\t\t\t\tall!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Remove an event handler for the given type.\n\t\t * If `handler` is omitted, all handlers of the given type are removed.\n\t\t * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n\t\t * @param {Function} [handler] Handler function to remove\n\t\t * @memberOf mitt\n\t\t */\n\t\toff<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\tif (handler) {\n\t\t\t\t\thandlers.splice(handlers.indexOf(handler) >>> 0, 1);\n\t\t\t\t} else {\n\t\t\t\t\tall!.set(type, []);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Invoke all handlers for the given type.\n\t\t * If present, `'*'` handlers are invoked after type-matched handlers.\n\t\t *\n\t\t * Note: Manually firing '*' handlers is not supported.\n\t\t *\n\t\t * @param {string|symbol} type The event type to invoke\n\t\t * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n\t\t * @memberOf mitt\n\t\t */\n\t\temit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n\t\t\tlet handlers = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as EventHandlerList<Events[keyof Events]>)\n\t\t\t\t\t.slice()\n\t\t\t\t\t.map((handler) => {\n\t\t\t\t\t\thandler(evt!);\n\t\t\t\t\t});\n\t\t\t}\n\n\t\t\thandlers = all!.get('*');\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as WildCardEventHandlerList<Events>)\n\t\t\t\t\t.slice()\n\t\t\t\t\t.map((handler) => {\n\t\t\t\t\t\thandler(type, evt!);\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t};\n}\n"],"names":["all","Map","on","type","handler","handlers","get","push","set","off","splice","indexOf","emit","evt","slice","map"],"mappings":"wBA8CCA,GAOA,MAAO,CAINA,IANDA,EAAMA,GAAO,IAAIC,IAchBC,YAA6BC,EAAWC,GACvC,IAAMC,EAAmDL,EAAKM,IAAIH,GAC9DE,EACHA,EAASE,KAAKH,GAEdJ,EAAKQ,IAAIL,EAAM,CAACC,KAWlBK,aAA8BN,EAAWC,GACxC,IAAMC,EAAmDL,EAAKM,IAAIH,GAC9DE,IACCD,EACHC,EAASK,OAAOL,EAASM,QAAQP,KAAa,EAAG,GAEjDJ,EAAKQ,IAAIL,EAAM,MAelBS,cAA+BT,EAAWU,GACzC,IAAIR,EAAWL,EAAKM,IAAIH,GACpBE,GACFA,EACCS,QACAC,IAAI,SAACX,GACLA,EAAQS,MAIXR,EAAWL,EAAKM,IAAI,OAElBD,EACCS,QACAC,IAAI,SAACX,GACLA,EAAQD,EAAMU"}

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/dist/mitt.umd.js

@@ -0,0 +1,2 @@
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e=e||self).mitt=n()}(this,function(){return function(e){return{all:e=e||new Map,on:function(n,t){var f=e.get(n);f?f.push(t):e.set(n,[t])},off:function(n,t){var f=e.get(n);f&&(t?f.splice(f.indexOf(t)>>>0,1):e.set(n,[]))},emit:function(n,t){var f=e.get(n);f&&f.slice().map(function(e){e(t)}),(f=e.get("*"))&&f.slice().map(function(e){e(n,t)})}}}});
+//# sourceMappingURL=mitt.umd.js.map

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/dist/mitt.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mitt.umd.js","sources":["../src/index.ts"],"sourcesContent":["export type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (\n\ttype: keyof T,\n\tevent: T[keyof T]\n) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<\n\tWildcardHandler<T>\n>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n\tkeyof Events | '*',\n\tEventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n\tall: EventHandlerMap<Events>;\n\n\ton<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n\ton(type: '*', handler: WildcardHandler<Events>): void;\n\n\toff<Key extends keyof Events>(\n\t\ttype: Key,\n\t\thandler?: Handler<Events[Key]>\n\t): void;\n\toff(type: '*', handler: WildcardHandler<Events>): void;\n\n\temit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n\temit<Key extends keyof Events>(\n\t\ttype: undefined extends Events[Key] ? Key : never\n\t): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n\tall?: EventHandlerMap<Events>\n): Emitter<Events> {\n\ttype GenericEventHandler =\n\t\t| Handler<Events[keyof Events]>\n\t\t| WildcardHandler<Events>;\n\tall = all || new Map();\n\n\treturn {\n\t\t/**\n\t\t * A Map of event names to registered handler functions.\n\t\t */\n\t\tall,\n\n\t\t/**\n\t\t * Register an event handler for the given type.\n\t\t * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n\t\t * @param {Function} handler Function to call in response to given event\n\t\t * @memberOf mitt\n\t\t */\n\t\ton<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\thandlers.push(handler);\n\t\t\t} else {\n\t\t\t\tall!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Remove an event handler for the given type.\n\t\t * If `handler` is omitted, all handlers of the given type are removed.\n\t\t * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n\t\t * @param {Function} [handler] Handler function to remove\n\t\t * @memberOf mitt\n\t\t */\n\t\toff<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n\t\t\tconst handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\tif (handler) {\n\t\t\t\t\thandlers.splice(handlers.indexOf(handler) >>> 0, 1);\n\t\t\t\t} else {\n\t\t\t\t\tall!.set(type, []);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Invoke all handlers for the given type.\n\t\t * If present, `'*'` handlers are invoked after type-matched handlers.\n\t\t *\n\t\t * Note: Manually firing '*' handlers is not supported.\n\t\t *\n\t\t * @param {string|symbol} type The event type to invoke\n\t\t * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n\t\t * @memberOf mitt\n\t\t */\n\t\temit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n\t\t\tlet handlers = all!.get(type);\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as EventHandlerList<Events[keyof Events]>)\n\t\t\t\t\t.slice()\n\t\t\t\t\t.map((handler) => {\n\t\t\t\t\t\thandler(evt!);\n\t\t\t\t\t});\n\t\t\t}\n\n\t\t\thandlers = all!.get('*');\n\t\t\tif (handlers) {\n\t\t\t\t(handlers as WildCardEventHandlerList<Events>)\n\t\t\t\t\t.slice()\n\t\t\t\t\t.map((handler) => {\n\t\t\t\t\t\thandler(type, evt!);\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t};\n}\n"],"names":["all","Map","on","type","handler","handlers","get","push","set","off","splice","indexOf","emit","evt","slice","map"],"mappings":"6LA8CCA,GAOA,MAAO,CAINA,IANDA,EAAMA,GAAO,IAAIC,IAchBC,YAA6BC,EAAWC,GACvC,IAAMC,EAAmDL,EAAKM,IAAIH,GAC9DE,EACHA,EAASE,KAAKH,GAEdJ,EAAKQ,IAAIL,EAAM,CAACC,KAWlBK,aAA8BN,EAAWC,GACxC,IAAMC,EAAmDL,EAAKM,IAAIH,GAC9DE,IACCD,EACHC,EAASK,OAAOL,EAASM,QAAQP,KAAa,EAAG,GAEjDJ,EAAKQ,IAAIL,EAAM,MAelBS,cAA+BT,EAAWU,GACzC,IAAIR,EAAWL,EAAKM,IAAIH,GACpBE,GACFA,EACCS,QACAC,IAAI,SAACX,GACLA,EAAQS,MAIXR,EAAWL,EAAKM,IAAI,OAElBD,EACCS,QACAC,IAAI,SAACX,GACLA,EAAQD,EAAMU"}

package/node_modules/.pnpm/chromium-bidi@12.1.0_devtools-protocol@0.0.1663043/node_modules/mitt/index.d.ts

@@ -0,0 +1,21 @@
+export declare type EventType = string | symbol;
+export declare type Handler<T = unknown> = (event: T) => void;
+export declare type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+export declare type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export declare type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+export declare type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+export interface Emitter<Events extends Record<EventType, unknown>> {
+    all: EventHandlerMap<Events>;
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+    on(type: '*', handler: WildcardHandler<Events>): void;
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: '*', handler: WildcardHandler<Events>): void;
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export default function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events>;