pi-proactive 0.0.0-stage → 0.2.0-beta.2

package/build/src/trigger.js

@@ -0,0 +1,458 @@
+import { digestOf } from "./lineage.js";
+/** 注入内容自带来源前缀（custom 消息在 LLM 层会变成 role:"user"，模型无法自行区分来源）。 */
+const SOURCE_PREFIX = "[来自 proactive]";
+/** 本地触发的 customType（跨进程 peer 用 "proactive:peer"，M4 才需要）。 */
+const LOCAL_CUSTOM_TYPE = "proactive:task";
+/** 跨进程 peer 消息的来源标记（与扩展入口的 PEER_CUSTOM_TYPE 同值；src 不反向依赖 extensions）。 */
+const PEER_CUSTOM_TYPE = "proactive:peer";
+/** 入站对端提问的「回信句柄」行前缀（让被问方一眼看出这是一条**待应答**的提问）。 */
+const ASK_HANDLE_PREFIX = "[待应答的对端提问]";
+/**
+ * 注入正文里的**回信句柄**行（规范 §6.5）。
+ *
+ * 为什么必须有：被问方要能拿到**回信所需的 id**（`correlationId` + 线程键），
+ * 并且能分辨「这是一条对端的提问、等着回话」—— 否则它只会被当成普通消息答用户。
+ *
+ * 形态：**一行可读摘要**（不把 id 裸暴露成噪声），且**不要求模型做任何事**——
+ * 回信由**插件代劳**（`src/peer.ts` 的 `PeerResponder` → 回信信封）。
+ *
+ * @returns 句柄行；不是「带关联 id 的提问」时返回 `undefined`（普通消息不加这行）。
+ */
+export function formatAskHandle(msg) {
+    if (!msg || msg.kind !== "ask")
+        return undefined;
+    const correlationId = msg.correlationId;
+    if (correlationId === undefined || correlationId === "")
+        return undefined;
+    const thread = msg.threadId ?? "（无）";
+    return `${ASK_HANDLE_PREFIX} correlationId=${correlationId} · 线程=${thread} · 来自=${msg.from} —— 这是对端的一条待应答提问；你的回答将由插件自动回传给对方（无需调用任何工具）。`;
+}
+/**
+ * 投递触发器：把 Envelope 变成「模型回合」或「用户通知」。
+ *
+ * 语义见 M1 契约 §5，不得偏离：
+ * - intent === "notify" → 只 appendEntry + ctx.ui.notify，不启动回合；
+ * - askUser → 先 ctx.ui.select/input（必须带 { timeout: config.askTimeoutMs }）：
+ *   无 UI → 降级为 notify 并记录「无 UI，未能提问」；
+ *   **用户取消（Esc）→ 不消耗额度、不记 pending（记一条 declined 审计事件）、文案「已取消」**；
+ *   **超时未答 → 消耗额度、记 pending、文案「未在时限内收到回答，已记为待答」**（绝不无限等待）；
+ * - 交给模型时：宿主空闲 → sendMessage(msg, { triggerTurn: true })（不带 deliverAs）；
+ *   宿主忙 → sendMessage(msg, { deliverAs: intent === "interrupt" ? "steer" : "followUp" })。
+ *
+ * **记账点唯一**：护栏 check + record 只在本模块内发生；
+ * 调用方（idle/scheduler）不得自行 check/record（否则 askUser 的回答会被 defer 静默丢弃）。
+ *
+ * **额度记账在「提问有结论之后」**（O-1 裁决的直接后果）：askUser 路径先 check（提问**之前**判定，
+ * 额度不足就不打扰用户）→ 提问 → **拿到结论后**才 record：
+ * 回答 → 记一次（额度消耗）；超时未答 → 记一次（额度消耗）；**用户取消 → 不记（额度长度不变）**。
+ * 拿到回答后**直接投递，不再二次 check** —— 提问窗口内被别处占用的额度不得吞掉用户的回答。
+ *
+ * 为什么记账点后移：「Esc 取消 = 用户明确拒绝 → **不消耗额度**」这条裁决，与「开口即记账」不可兼得
+ * —— 额度账本（`src/guard.ts`）只有 `record()` 追加、没有撤销接口，开口的记账无法收回。
+ * 后移的副作用（提问窗口内本机不再被冷却挡住）由 `openQuestions` 就地补偿：
+ * 提问期间不叠加提问、不叠加本机投递（见 `openQuestions` 字段注释）。
+ *
+ * **回答归因不在本模块**：本模块**不产生任何回信**（不构造回信类信封），
+ * 也**不按「下一条 assistant 文本」做 FIFO 归因** —— 归因的唯一真源是
+ * `src/peer.ts` 的 `PeerResponder`（pending 队列 + `ambiguous` 降级）。
+ *
+ * 所有对外调用整体 try/catch：宿主 uncaughtException → process.exit(1)，异常不得冒泡。
+ */
+export class Trigger {
+    deps;
+    /** 未获回答的提问（记 pending，便于后续补问；仅本进程内存）。 */
+    pending = [];
+    /** 正在等待用户回答的提问数（提问期间本机不再叠加打扰）。 */
+    openQuestions = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * 把一条消息投递给模型（或降级为用户通知），并返回**最终**投递结果。
+     *
+     * **只有一个结果源**（契约 §5）：返回值即最终结果，调用方**必须 await 之后**再决策。
+     * 没有「结果回调」这条第二轨（回调通道已删除）—— 双轨必然漂移（提问前的 "notified" 会让调用方把
+     * 「回答被护栏 defer」误判成「已执行」→ 用户的回答被静默丢弃）。
+     *
+     * 返回值语义：
+     * - `intent === "notify"` → "notified"（零 token，未占额度）
+     * - `opts.askUser === true` → **await 到用户回答之后**才 resolve：
+     *   回答后真的投递 → "delivered"；**提问之前**额度不足（defer/drop）→ 不提问 → "deferred"/"dropped"；
+     *   无 UI → 降级 notify → "notified"；超时未答 → 记 pending + notify → "notified"；
+     *   用户取消（Esc）→ 不记 pending + notify「已取消」→ "notified"；异常 → "failed"。
+     * - 其余路径 → 本次投递结果。
+     */
+    async deliverToModel(msg, intent, opts) {
+        const cause = resolveCause(msg, opts?.cause);
+        try {
+            // **触发原因落盘（因）**：判定通过、决定触发的那一刻就把 cause + 判定依据写进事件流。
+            this.noteTriggered(msg, cause);
+            if (intent === "notify") {
+                this.notifyOnly(msg.subject ?? "proactive", msg.body, msg);
+                this.noteDelivery(msg, cause, "notified");
+                return "notified";
+            }
+            if (opts?.askUser === true) {
+                if (!this.deps.ctx.hasUI) {
+                    // 无 UI（json/print 模式）→ 降级为 notify，并记录「无 UI，未能提问」
+                    console.warn("[proactive] 无 UI，未能提问");
+                    this.notifyOnly(msg.subject ?? "proactive", `${msg.body}（无 UI，未能提问）`, msg);
+                    this.noteDelivery(msg, cause, "notified");
+                    return "notified";
+                }
+                // 提问是异步的 → 最终结果只能在 await 之后拿到。
+                return await this.askThenDeliver(msg, intent, opts.inboundPeer === true, cause);
+            }
+            return this.deliverToModelNow(msg, intent, cause, undefined, { skipGuard: opts?.inboundPeer === true });
+        }
+        catch (err) {
+            console.error("[proactive] deliverToModel 失败", err);
+            // 内层路径各自已记「失败」；这里只兜底异常冒泡（不重复记账）。
+            return "failed";
+        }
+    }
+    /** 只通知用户，不打扰模型（零 token）。 */
+    notify(title, message) {
+        this.notifyOnly(title, message);
+    }
+    // ---- 内部实现 ----
+    /** 用户通知路径：appendEntry（审计/落转录）+ ui.notify，绝不启动回合。 */
+    notifyOnly(title, message, msg) {
+        try {
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                kind: "notify",
+                title,
+                message,
+                agentId: this.deps.agentId,
+                envelopeId: msg?.id,
+                at: Date.now(),
+            });
+            this.deps.ctx.ui.notify(title ? `${title}: ${message}` : message);
+        }
+        catch (err) {
+            console.error("[proactive] notify 失败", err);
+        }
+    }
+    /**
+     * 向用户提问，并把结局分成**回答 / 用户取消（Esc）/ 超时未答**三种。
+     *
+     * **为什么必须自己计时**：宿主对「Esc 取消」与「超时」**都** resolve(undefined)
+     * （宿主源码 `dist/modes/interactive/components/extension-selector.js`：倒计时到期与取消键
+     * 走同一个 `onCancelCallback`；RPC 模式同样都归一到 undefined）→ **插件侧无法从返回值区分**。
+     * 因此这里自建**时限闸门**：闸门先到 → 「超时未答」；宿主在时限内先收场（空值）→ 「用户取消」。
+     *
+     * 闸门同时通过 `AbortSignal` 收起宿主对话框（宿主支持 `opts.signal`），
+     * 保证「时限到了」时对话框立刻消失，而不是等宿主自己的倒计时收尾。
+     */
+    async ask(msg) {
+        const question = msg.subject ?? msg.body;
+        const rawOptions = msg.options;
+        const options = Array.isArray(rawOptions) ? rawOptions : undefined;
+        const timeoutMs = this.deps.config.askTimeoutMs;
+        const controller = new AbortController();
+        // 绝对到期时刻：宿主自己的超时计时器在**我们之后**才启动 → 它的到期时刻必然 ≥ 本值。
+        const deadlineAt = Date.now() + timeoutMs;
+        let timer;
+        // 兜底闸门：万一宿主不兑现 timeout（不该发生），到点我们自己收场（并收起对话框）。
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                resolve({ status: "timeout" });
+                controller.abort();
+            }, timeoutMs);
+            // 兜底闸门**不拖住进程退出**（unref）：它只在「宿主不兑现 timeout」时兜底，
+            // 宿主进程本来就长期存活（stdin 等句柄在），到期照样会触发 → 对话框被 abort 收起。
+            // 且它在 finally 里被 clearTimeout → 正常路径零残留（不留孤儿定时器）。
+            timer.unref?.();
+        });
+        try {
+            const dialog = options && options.length > 0
+                ? this.deps.ctx.ui.select(question, options, { timeout: timeoutMs, signal: controller.signal })
+                : this.deps.ctx.ui.input(question, msg.body, { timeout: timeoutMs, signal: controller.signal });
+            // 宿主 reject（抛错）也要被吸收：闸门先赢时，宿主随后的 reject 不能变成 unhandledRejection。
+            const settled = await Promise.race([
+                dialog.then((value) => ({ status: "value", value }), (error) => ({ status: "error", error })),
+                deadline,
+            ]);
+            if (settled.status === "error")
+                throw settled.error;
+            if (settled.status === "timeout")
+                return { status: "timeout" };
+            const value = settled.value;
+            if (value === undefined || value === null || value === "") {
+                // 宿主交回空值 —— 它对「Esc 取消」与「超时」都这么干（见上）→ 用**是否已到期**区分：
+                // 宿主的超时计时器在**我们之后**才启动 → 它的到期时刻必然 ≥ 我们的到期时刻；
+                // 于是「已到期」= 超时未答，「未到期」= 用户主动取消（Esc）。
+                return Date.now() >= deadlineAt ? { status: "timeout" } : { status: "cancelled" };
+            }
+            return { status: "answered", answer: String(value) };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * askUser 路径：**先判额度（提问之前）→ 提问 → 按结论记账 → 回答则直接投递**。
+     *
+     * 契约（V-02 修复 + O-1 裁决）：
+     * - 无 UI → 降级 notify（不消耗额度）→ "notified"；
+     * - `guard.check(now)` → `defer` → **不提问**、返回 "deferred"（不消耗）；`drop` → "dropped"（不消耗）；
+     * - **用户取消（Esc）** → **不消耗额度**、**不记 pending**（记一条 `declined` 审计事件）、文案「已取消」→「notified」；
+     * - **超时未答** → 消耗额度、记 pending、文案「未在时限内收到回答，已记为待答」→「notified"；
+     * - 有回答 → 消耗额度 → **直接投递**（不再二次 check）→「delivered」。
+     *
+     * 理由（V-02 真实宿主冒烟 Blocker-1）：提问窗口内若发生另一次主动投递，占用的额度不得把
+     * **已获得的用户回答** defer 掉（否则用户的回答被静默丢弃且永久丢失）。
+     *
+     * 备注：投递失败（异常）时额度已消耗 —— 属可接受（我们确实已经打扰了用户）。
+     */
+    async askThenDeliver(msg, intent, inboundPeer, cause) {
+        try {
+            const now = Date.now();
+            // ⓪ 提问期间不再叠加提问（等价于旧「开口即记账」带来的冷却效果，见类注释）。
+            if (!inboundPeer && this.openQuestions > 0) {
+                console.warn("[proactive] 已有提问在等待回答，本次不叠加提问");
+                this.noteDropped(msg, cause, "defer");
+                return "deferred";
+            }
+            // ① 开口之前先判定额度：额度不足就**不打扰**用户（也不消耗额度）。
+            //    入站 peer 协作消息**不受**本机主动触发的频率闸门约束（见 DeliverOptions.inboundPeer）。
+            if (!inboundPeer) {
+                const verdict = this.deps.guard.check(now);
+                if (verdict !== "allow") {
+                    console.warn(`[proactive] 护栏判定 ${verdict}，本次不提问`);
+                    this.noteDropped(msg, cause, verdict);
+                    return verdict === "defer" ? "deferred" : "dropped";
+                }
+            }
+            // ② 提问（带 timeout + 自建时限闸门 → 能区分「取消」与「超时」）。
+            this.openQuestions++;
+            let asked;
+            try {
+                asked = await this.ask(msg);
+            }
+            finally {
+                this.openQuestions--;
+            }
+            if (asked.status === "cancelled") {
+                // 用户明确拒绝 → **不消耗额度**、**不记 pending**（只留一条 declined 审计事件）。
+                console.warn("[proactive] 用户取消提问（已取消）：不消耗额度、不记待答");
+                this.recordDeclined(msg);
+                this.notifyOnly(msg.subject ?? "proactive", `${msg.body}（已取消）`, msg);
+                this.noteDelivery(msg, cause, "notified");
+                return "notified";
+            }
+            // ③ 用户确实被问过（回答或超时未答）→ 额度在此刻消耗（一次）。
+            if (!inboundPeer)
+                this.deps.guard.record(Date.now());
+            if (asked.status === "timeout") {
+                console.warn("[proactive] 提问未获回答，记为 pending");
+                this.recordPending(msg);
+                this.notifyOnly(msg.subject ?? "proactive", `${msg.body}（未在时限内收到回答，已记为待答）`, msg);
+                this.noteDelivery(msg, cause, "notified");
+                return "notified";
+            }
+            // ④ 拿到回答 → 直接投递（不再二次 check：额度已记，提问窗口内被别处占用的额度不得吞掉用户的回答）。
+            return this.deliverToModelNow(msg, intent, cause, asked.answer, { skipGuard: true });
+        }
+        catch (err) {
+            console.error("[proactive] askUser 失败", err);
+            this.noteDelivery(msg, cause, "failed", "exception");
+            return "failed";
+        }
+    }
+    recordPending(msg) {
+        const question = msg.subject ?? msg.body;
+        this.pending.push({ question, envelopeId: msg.id, at: Date.now() });
+        try {
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                stage: "pending",
+                question,
+                envelopeId: msg.id,
+                agentId: this.deps.agentId,
+                at: Date.now(),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] recordPending 失败", err);
+        }
+    }
+    /**
+     * 用户**主动取消**（Esc）的审计事件：只留痕，不记待答、不消耗额度。
+     *
+     * 用 `stage:"declined"`（**不用** `kind`）—— 与 `stage:"pending"` / `stage:"deliver"` 同族，
+     * 避免与宿主自定义消息的 `kind` 字段撞名（历史缺陷：kind 同时被用作消息类型与记录判别键）。
+     */
+    recordDeclined(msg) {
+        const question = msg.subject ?? msg.body;
+        try {
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                stage: "declined",
+                message: "已取消",
+                question,
+                envelopeId: msg.id,
+                agentId: this.deps.agentId,
+                at: Date.now(),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] recordDeclined 失败", err);
+        }
+    }
+    /**
+     * 交给模型：空闲 → 启动新回合；忙 → steer/followUp 插入当前回合。
+     * 护栏统一在此把守（护栏计数作用域 = 每 agent）；notify 不占额度（零 token，不启动回合）。
+     *
+     * **记账点唯一**：check 通过 → appendEntry → record → sendMessage，全部只在这里发生；
+     * 调用方不得自行 check/record（否则 askUser 路径的回答会被 defer 静默丢弃）。
+     *
+     * `skipGuard`：**额度已在 askUser 路径记过**（回答/超时）或**本就是入站协作**（不消耗本机额度）
+     * → 投递时既不再 check 也不再 record。
+     */
+    deliverToModelNow(msg, intent, cause, answer, opts) {
+        const now = Date.now();
+        const skipGuard = opts?.skipGuard === true;
+        try {
+            if (!skipGuard) {
+                // 提问期间不再叠加本机投递（等价于旧「开口即记账」带来的冷却效果，见类注释）。
+                if (this.openQuestions > 0) {
+                    console.warn("[proactive] 已有提问在等待回答，本次不叠加投递");
+                    this.noteDropped(msg, cause, "defer");
+                    return "deferred";
+                }
+                const verdict = this.deps.guard.check(now);
+                if (verdict !== "allow") {
+                    console.warn(`[proactive] 护栏判定 ${verdict}，本次不投递`);
+                    this.noteDropped(msg, cause, verdict);
+                    return verdict === "defer" ? "deferred" : "dropped";
+                }
+            }
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                stage: "deliver",
+                envelopeId: msg.id,
+                from: msg.from,
+                to: msg.to,
+                subject: msg.subject,
+                intent,
+                answer,
+                agentId: this.deps.agentId,
+                at: Date.now(),
+            });
+            // 记账点唯一：check 已通过 → 在真正投递前记账（调用方不得自行 record）。
+            // skipGuard 时额度已在 askUser 路径记过（回答/超时），或本就是入站协作（不消耗本机额度）。
+            if (!skipGuard)
+                this.deps.guard.record(now);
+            // 来源标记：跨进程 peer 消息用 `msg.customType`（"proactive:peer"），
+            // 本地触发仍用 LOCAL_CUSTOM_TYPE —— 模型据此区分消息来源。
+            const custom = {
+                customType: msg.customType ?? LOCAL_CUSTOM_TYPE,
+                content: this.buildContent(msg, answer),
+                display: true,
+            };
+            if (this.deps.ctx.isIdle()) {
+                // 空闲：带 triggerTurn 启动新回合（不带 deliverAs —— 空闲时 deliverAs 不生效）
+                this.deps.pi.sendMessage(custom, { triggerTurn: true });
+            }
+            else {
+                // 忙（streaming）：deliverAs 仅在 streaming 生效
+                this.deps.pi.sendMessage(custom, {
+                    deliverAs: intent === "interrupt" ? "steer" : "followUp",
+                });
+            }
+            // 投递确实发生（模型接手）→ 记「果」的起点：事件流据此开判定窗口。
+            this.noteDelivery(msg, cause, "delivered");
+            return "delivered";
+        }
+        catch (err) {
+            console.error("[proactive] deliverToModelNow 失败", err);
+            this.noteDelivery(msg, cause, "failed", "exception");
+            return "failed";
+        }
+    }
+    // ---- 血缘（事件流）接线 ----
+    /**
+     * 记一次「触发」（因）：cause + 判定依据 + 正文**长度/摘要**（**不含正文**）。
+     *
+     * 事件流写失败**不得**影响投递语义（宿主 uncaughtException → process.exit(1)）。
+     */
+    noteTriggered(msg, cause) {
+        try {
+            const body = typeof msg.body === "string" ? msg.body : "";
+            this.deps.lineage?.noteTriggered({
+                cause: cause.type,
+                envelopeId: msg.id,
+                ...(cause.basis !== undefined ? { basis: cause.basis } : {}),
+                ...(cause.peer !== undefined ? { peer: cause.peer } : {}),
+                ...(cause.taskId !== undefined ? { taskId: cause.taskId } : {}),
+                bodyLen: body.length,
+                bodyDigest: digestOf(body),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] 记事件流失败", err);
+        }
+    }
+    /**
+     * 记一次「投递完成」；投递成功时回调 `onDelivered`（供派生任务绑定 `triggeredBy`）。
+     */
+    noteDelivery(msg, cause, result, reason) {
+        try {
+            const event = this.deps.lineage?.noteDelivery({
+                cause: cause.type,
+                result,
+                envelopeId: msg.id,
+                ...(cause.basis !== undefined ? { basis: cause.basis } : {}),
+                ...(cause.peer !== undefined ? { peer: cause.peer } : {}),
+                ...(cause.taskId !== undefined ? { taskId: cause.taskId } : {}),
+                ...(reason !== undefined ? { reason } : {}),
+            });
+            if (result === "delivered" && event !== undefined) {
+                try {
+                    this.deps.onDelivered?.({ envelopeId: msg.id, eventId: event.id, cause: cause.type, ts: event.ts });
+                }
+                catch (err) {
+                    console.error("[proactive] onDelivered 回调失败", err);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[proactive] 记事件流失败", err);
+        }
+    }
+    /** 记一次「被拦下」（护栏 / 前置条件）：带原因。 */
+    noteDropped(msg, cause, reason) {
+        try {
+            this.deps.lineage?.noteDropped({
+                cause: cause.type,
+                reason,
+                envelopeId: msg.id,
+                ...(cause.basis !== undefined ? { basis: cause.basis } : {}),
+                ...(cause.peer !== undefined ? { peer: cause.peer } : {}),
+                ...(cause.taskId !== undefined ? { taskId: cause.taskId } : {}),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] 记事件流失败", err);
+        }
+    }
+    /** 注入内容自带来源前缀（调用方传裸 body，避免双前缀）。 */
+    buildContent(msg, answer) {
+        const body = msg.body.startsWith(SOURCE_PREFIX) ? msg.body : `${SOURCE_PREFIX} ${msg.body}`;
+        const handle = formatAskHandle(msg);
+        const content = handle === undefined ? body : `${body}\n${handle}`;
+        return answer === undefined ? content : `${content}\n[用户回答] ${answer}`;
+    }
+}
+/**
+ * 触发原因（缺省时按信封来源**推断**）。
+ *
+ * 推断只是兜底：`customType === "proactive:peer"` 的入站协作消息 → peer-request，
+ * 其余 → manual。真实调用方（扩展入口）应当显式给出 cause 与判定依据。
+ */
+function resolveCause(msg, cause) {
+    if (cause !== undefined)
+        return cause;
+    if (msg.customType === PEER_CUSTOM_TYPE)
+        return { type: "peer-request" };
+    return { type: "manual" };
+}

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/typebox/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;

package/node_modules/typebox/build/compile/code.mjs

@@ -0,0 +1,64 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// Comments and Formatting
+// ------------------------------------------------------------------
+function TsIgnore() {
+    return `// @ts-ignore`;
+}
+function Separator() {
+    return ``;
+}
+// ------------------------------------------------------------------
+// ImportSection
+// ------------------------------------------------------------------
+function ImportSection(build) {
+    const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
+    const hashing = `import { Hashing } from "typebox/system"`;
+    const guard = `import { Guard } from "typebox/guard"`;
+    return [...context, hashing, guard];
+}
+// ------------------------------------------------------------------
+// ExternalSection
+// ------------------------------------------------------------------
+function ExternalSection(build) {
+    const { identifier } = build.External();
+    return [
+        Separator(),
+        TsIgnore(),
+        `let ${identifier} = []`,
+        Separator(),
+        TsIgnore(),
+        `export function SetExternal(external) { ${identifier} = external.variables }`
+    ];
+}
+// ------------------------------------------------------------------
+// FunctionSection
+// ------------------------------------------------------------------
+function FunctionSection(build) {
+    return build.Functions().map((func) => [Separator(), TsIgnore(), `${func};`].join('\n'));
+}
+// ------------------------------------------------------------------
+// ExportSection
+// ------------------------------------------------------------------
+function ExportSection(build) {
+    const body = build.UseUnevaluated()
+        ? `const context = new CheckContext({}, {}); return ${build.Entry()}`
+        : `return ${build.Entry()}`;
+    return [
+        Separator(),
+        TsIgnore(),
+        `export function Check(value) { ${body} }`
+    ];
+}
+/** Creates a standalone ESM validation module for the given type. */
+export function Code(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    const build = Build(context, type);
+    const code = [...ImportSection(build), ...ExternalSection(build), ...FunctionSection(build), ...ExportSection(build)].join('\n');
+    return { External: build.External(), Code: code };
+}

package/node_modules/typebox/build/compile/compile.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export declare function Compile<const Type extends TSchema, Result extends Validator = Validator<{}, Type>>(type: Type): Result;
+/** Compiles a type into a high performance Validator */
+export declare function Compile<Context extends TProperties, const Type extends TSchema, Result extends Validator = Validator<Context, Type>>(context: Context, type: Type): Result;

package/node_modules/typebox/build/compile/compile.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export function Compile(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return new Validator(context, type);
+}

package/node_modules/typebox/build/compile/index.d.mts

@@ -0,0 +1,8 @@
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/index.mjs

@@ -0,0 +1,14 @@
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/validator.d.mts

@@ -0,0 +1,35 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema } from '../type/index.mjs';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> {
+    private readonly hasCodec;
+    private readonly buildResult;
+    private readonly evaluateResult;
+    /** Constructs a Validator. */
+    constructor(context: Context, type: Type);
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated(): boolean;
+    /** Returns the Context for this validator. */
+    Context(): Context;
+    /** Returns the underlying Type used to construct this Validator. */
+    Type(): Type;
+    /** Returns the generated code for this validator. */
+    Code(): string;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
+    /** Returns an array of validation errors for the given value. */
+    Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
+    Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
+    Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
+    Create(): Encode;
+    /** Creates defaults using the Validator type. */
+    Default(value: unknown): unknown;
+    /** Decodes a value */
+    Decode(value: unknown): Decode;
+    /** Encodes a value */
+    Encode(value: unknown): Encode;
+}