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

package/build/src/trust-policy.js

@@ -0,0 +1,58 @@
+/**
+ * 主动性策略：**空闲触发降级为默认浅层**（卡 D2）。
+ *
+ * 依据 `docs/product/assistant-trust-model.md` §3：
+ * > 空闲触发只是**默认浅层用法**（应默认静默、能等就等）；主动性的真正来源是**用户的托付**。
+ *
+ * 判据（两条闸门，缺一即不开口）：
+ * 1. **有用户交代**：没有任何托付 / 未竟目标支撑 → 不开口（默认静默）；
+ * 2. **确有价值**：DECIDE1 分数低于阈值 → 不开口（不产生无价值打扰）。
+ *
+ * 分数**复用 DECIDE1**（`src/idle.ts:scoreDecision` —— 同一把尺子，不另立公式），
+ * 输入的三个分量各自带**来源**（可复核「这个数从哪来」）。
+ *
+ * @capability: trust-shallow-idle
+ * @observable: pi-proactive/src/trust-policy.ts:evaluateShallowIdle
+ * @attribution: pi-proactive/src/trust-policy.ts:evaluateShallowIdle
+ * @outcome: pi-proactive/src/trigger.ts:Trigger
+ * @checked: test:pi-proactive/tests/trust-policy.test.ts#D2-4 接线实证
+ */
+import { scoreDecision } from "./idle.js";
+/** 浅层策略的缺省值（**默认静默**）。 */
+export const DEFAULT_SHALLOW_IDLE_POLICY = {
+    enabled: true,
+    requireUserBacking: true,
+    threshold: 1,
+    observeRatio: 0.5,
+};
+/**
+ * 浅层空闲判定（纯函数）。
+ *
+ * - **默认静默**：没有用户交代 → `speak=false`（reason = `no-backing`）；
+ * - **不产生无价值打扰**：分数 < 阈值 → `speak=false`（reason = `below-threshold`）；
+ * - 两条都过 → `speak=true`（reason = `speak`）。
+ */
+export function evaluateShallowIdle(input) {
+    const scoring = scoreDecision({
+        value: { score: input.value, source: input.valueSource },
+        urgency: { score: input.urgency, source: input.urgencySource },
+        interruptionCost: { score: input.interruptionCost, source: input.interruptionCostSource },
+    }, input.policy.threshold, input.policy.observeRatio);
+    if (input.policy.requireUserBacking && !input.backedByUserRequest) {
+        return { speak: false, reason: "no-backing", score: scoring.score };
+    }
+    if (scoring.band !== "trigger") {
+        return { speak: false, reason: "below-threshold", score: scoring.score };
+    }
+    return { speak: true, reason: "speak", score: scoring.score };
+}
+/**
+ * 这条信封是不是**空闲触发**（`src/idle.ts:buildIdleEnvelope` 造出来的）。
+ *
+ * 为什么用信封标记而不是 `cause`：既有空闲路径**没有**把 `cause:"idle"` 传给投递层
+ * （`src/idle.ts` 的 `fireIdle` → `deliverToModel` 不带 cause）→ 投递层只能靠信封自身
+ * 的确定性标记识别（`id` 前缀 + `subject`），两者都由 `buildIdleEnvelope` 固定生成。
+ */
+export function isIdleTriggerEnvelope(msg) {
+    return msg.id.startsWith("idle-") || msg.subject === "空闲触发";
+}

package/build/src/trust-registry.js

@@ -0,0 +1,323 @@
+/**
+ * 托付与目标的**登记册**（信任层的事实源 · 卡 D1/D6）。
+ *
+ * 为什么要有登记册：托付（"盯着 X"）与目标（"把发布流程跑通"）若只存在于对话里，
+ * 就**无法查、无法撤、无法结账** → 主动性的价值无从证明。登记册把二者变成
+ * **有状态、可查、可撤销**的记录，每次状态变化都落成**只追加**的事件（`src/lineage.ts`）。
+ *
+ * 设计要点（对齐 `docs/product/agentic-loop.md` 与 `docs/product/assistant-trust-model.md`）：
+ * - **托付 = 目标 + 条件**（L-B 是 L-C 的一个实例）：托付带一个**可判定**的到达条件；
+ * - **目标必须可判定完成**：`doneWhen` 缺失或不可判定 → 目标**不得**进入自主推进（护栏①）；
+ * - **状态机是显式的**：托付 `active → arrived → notified → settled`（或 `revoked`）；
+ *   目标 `open → achieved | abandoned | needs-human` —— 「需人决策」是**一等状态**，
+ *   不允许被静默折叠成「完成」；
+ * - **落盘是原子的**：临时文件 + rename（避免半截 JSON 读坏整个登记册）；
+ * - **不越界**：目标带 `scope`（范围标签）—— 自主推进只能改变范围内的状态。
+ *
+ * 落盘位置：`<agentDir>/proactive/trust/registry.json`（与邮箱 / 线程 / 事件流同族目录）。
+ *
+ * @capability: trust-entrust
+ * @observable: pi-proactive/src/trust-registry.ts:TrustRegistry
+ * @attribution: pi-proactive/src/trust-registry.ts:TrustRegistry.registerEntrustment
+ * @outcome: pi-proactive/src/trust-metrics.ts:ConservationReport
+ * @checked: test:pi-proactive/tests/trust-registry.test.ts#D1-2 四段闭环成立
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { ensureDir, writeAtomicFile } from "./config.js";
+/** 登记册文件格式版本。 */
+export const REGISTRY_SCHEMA_VERSION = 1;
+/** 目标是否**可判定完成**（护栏①的判据）。 */
+export function isDecidable(goal) {
+    const d = goal.doneWhen;
+    if (d === undefined)
+        return false;
+    if (d.type === "checklist")
+        return d.items.length > 0;
+    return Number.isFinite(d.target);
+}
+/** 目标是否**已达成**（按完成定义判定，缺省定义 → 未达成）。 */
+export function goalSatisfied(goal) {
+    const d = goal.doneWhen;
+    if (d === undefined)
+        return false;
+    if (d.type === "checklist")
+        return d.items.length > 0 && d.items.every((i) => i.done);
+    if (d.op === ">=")
+        return d.current >= d.target;
+    if (d.op === "<=")
+        return d.current <= d.target;
+    return d.current === d.target;
+}
+/** 目标差距（还差多少 / 哪些没做完）—— 候选行动的来源。 */
+export function goalGap(goal) {
+    const d = goal.doneWhen;
+    if (d === undefined)
+        return { remaining: 1, total: 1, ratio: 1, items: [] };
+    if (d.type === "checklist") {
+        const undone = d.items.filter((i) => !i.done);
+        return {
+            remaining: undone.length,
+            total: d.items.length,
+            ratio: d.items.length === 0 ? 1 : undone.length / d.items.length,
+            items: undone.map((i) => i.text),
+        };
+    }
+    const span = Math.abs(d.target - d.current);
+    const step = span === 0 ? 1 : Math.max(1, Math.abs(d.target));
+    return { remaining: span, total: step, ratio: Math.min(1, span / step), items: [`${d.name} → ${d.op} ${d.target}`] };
+}
+/**
+ * 托付与目标的登记册（单一事实源）。
+ *
+ * 状态迁移全部走**显式方法**（`markArrived` / `markNotified` / `settle` / `revoke`），
+ * 不允许调用方直接改状态 → 状态机只有一处实现，事件流与登记册不会漂移。
+ */
+export class TrustRegistry {
+    agentDir;
+    ownerAgentId;
+    now;
+    goals = [];
+    entrustments = [];
+    /** 载入时的坏数据计数（读不动的记录被跳过，不抛错）。 */
+    stale = 0;
+    constructor(opts) {
+        this.agentDir = opts.agentDir;
+        this.ownerAgentId = opts.agentId;
+        this.now = opts.now ?? Date.now;
+        this.load();
+    }
+    /** 登记册文件绝对路径。 */
+    path() {
+        return path.join(this.agentDir, "proactive", "trust", "registry.json");
+    }
+    /** 载入登记册（文件缺失 → 空册；坏记录 → 跳过并计数，绝不抛错）。 */
+    load() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.path(), "utf8");
+        }
+        catch {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            this.stale += 1;
+            return;
+        }
+        const file = parsed;
+        this.goals = Array.isArray(file.goals) ? file.goals.filter((g) => g && typeof g.id === "string") : [];
+        this.entrustments = Array.isArray(file.entrustments)
+            ? file.entrustments.filter((e) => e && typeof e.id === "string")
+            : [];
+    }
+    /** 落盘（临时文件 + rename → 原子；失败不抛错，只记日志）。 */
+    save() {
+        const file = this.path();
+        const payload = { schemaVersion: REGISTRY_SCHEMA_VERSION, goals: this.goals, entrustments: this.entrustments };
+        try {
+            ensureDir(path.dirname(file));
+            writeAtomicFile(file, `${JSON.stringify(payload, null, 2)}\n`);
+        }
+        catch (err) {
+            console.error("[proactive] 托付登记册落盘失败", err);
+        }
+    }
+    /** 载入时跳过的坏记录数（审计用）。 */
+    staleRecords() {
+        return this.stale;
+    }
+    // ---- 目标 ----
+    /** 登记一个目标（**完成定义缺省 = 不可判定** → 由护栏拦住自主推进）。 */
+    registerGoal(input) {
+        const at = this.now();
+        const goal = {
+            id: input.id ?? randomUUID(),
+            title: input.title,
+            ...(input.doneWhen !== undefined ? { doneWhen: input.doneWhen } : {}),
+            status: "open",
+            scope: input.scope ?? [],
+            budget: { maxActions: input.maxActions ?? 8, usedActions: 0 },
+            permission: input.permission ?? "auto",
+            progressSteps: 0,
+            createdAt: at,
+            updatedAt: at,
+        };
+        this.goals = [...this.goals.filter((g) => g.id !== goal.id), goal];
+        this.save();
+        return goal;
+    }
+    /** 取目标（不存在 → undefined）。 */
+    getGoal(id) {
+        return this.goals.find((g) => g.id === id);
+    }
+    /** 全部目标（按登记顺序）。 */
+    listGoals() {
+        return [...this.goals];
+    }
+    /** 未竟目标（`open`；自主推进的发现来源之一）。 */
+    listOpenGoals() {
+        return this.goals.filter((g) => g.status === "open");
+    }
+    /** 勾选清单项 / 更新指标当前值（完成定义的推进）。 */
+    updateDoneWhen(goalId, update) {
+        const goal = this.getGoal(goalId);
+        if (goal === undefined || goal.doneWhen === undefined)
+            return undefined;
+        if (goal.doneWhen.type === "checklist" && update.itemId !== undefined) {
+            goal.doneWhen.items = goal.doneWhen.items.map((i) => i.id === update.itemId ? { ...i, done: update.itemDone === true } : i);
+        }
+        if (goal.doneWhen.type === "metric" && update.metricCurrent !== undefined) {
+            goal.doneWhen.current = update.metricCurrent;
+        }
+        goal.updatedAt = this.now();
+        this.save();
+        return goal;
+    }
+    /** 归因推进：这次行动让目标前进了 `delta` 步（可追溯⑤的载体）。 */
+    recordProgress(goalId, delta) {
+        const goal = this.getGoal(goalId);
+        if (goal === undefined)
+            return undefined;
+        goal.progressSteps += delta;
+        goal.updatedAt = this.now();
+        this.save();
+        return goal;
+    }
+    /** 消耗预算（护栏②）：超出上限 → 返回 false（调用方必须停）。 */
+    consumeBudget(goalId, amount = 1) {
+        const goal = this.getGoal(goalId);
+        if (goal === undefined)
+            return false;
+        if (goal.budget.usedActions + amount > goal.budget.maxActions)
+            return false;
+        goal.budget.usedActions += amount;
+        goal.updatedAt = this.now();
+        this.save();
+        return true;
+    }
+    /**
+     * 设置目标状态。
+     *
+     * `needs-human` **必须**带原因（否则就是「静默结账」的变体 → 违反红线）。
+     */
+    setGoalStatus(goalId, status, humanReason) {
+        const goal = this.getGoal(goalId);
+        if (goal === undefined)
+            return undefined;
+        if (status === "needs-human" && (humanReason === undefined || humanReason.trim() === "")) {
+            return undefined;
+        }
+        goal.status = status;
+        if (status === "needs-human")
+            goal.humanReason = humanReason;
+        goal.updatedAt = this.now();
+        this.save();
+        return goal;
+    }
+    // ---- 托付 ----
+    /** 登记一条托付（"盯着 X"）。 */
+    registerEntrustment(input) {
+        const at = this.now();
+        const e = {
+            id: input.id ?? randomUUID(),
+            target: input.target,
+            condition: input.condition,
+            status: "active",
+            ...(input.goalId !== undefined ? { goalId: input.goalId } : {}),
+            ...(input.needsHuman !== undefined ? { needsHuman: input.needsHuman } : {}),
+            ...(input.humanReason !== undefined ? { humanReason: input.humanReason } : {}),
+            createdAt: at,
+        };
+        this.entrustments = [...this.entrustments.filter((x) => x.id !== e.id), e];
+        this.save();
+        return e;
+    }
+    /** 取托付（不存在 → undefined）。 */
+    getEntrustment(id) {
+        return this.entrustments.find((e) => e.id === id);
+    }
+    /** 全部托付。 */
+    listEntrustments() {
+        return [...this.entrustments];
+    }
+    /** 未闭合托付（`active` / `arrived` / `notified` —— 自主推进的发现来源之二）。 */
+    listUnclosedEntrustments() {
+        return this.entrustments.filter((e) => e.status === "active" || e.status === "arrived" || e.status === "notified");
+    }
+    /** 到达（第二段）：条件已满足。 */
+    markArrived(id) {
+        const e = this.getEntrustment(id);
+        if (e === undefined || e.status !== "active")
+            return undefined;
+        e.status = "arrived";
+        e.arrivedAt = this.now();
+        this.save();
+        return e;
+    }
+    /**
+     * 知会（第三段）。
+     *
+     * **幂等**：已 `notified` 的托付再调用 → 返回 undefined（不重复知会、不重复落事件）。
+     * （双通道去重的账本侧：通知器与登记册任一方被重复调用都不会产生第二次知会。）
+     */
+    markNotified(id) {
+        const e = this.getEntrustment(id);
+        if (e === undefined || e.status !== "arrived")
+            return undefined;
+        e.status = "notified";
+        e.notifiedAt = this.now();
+        this.save();
+        return e;
+    }
+    /**
+     * 结账（第四段）。
+     *
+     * **需要人决定的托付不得自动结账**（D3）→ `needsHuman` 的托付调用本方法 → 返回 undefined。
+     */
+    settle(id) {
+        const e = this.getEntrustment(id);
+        if (e === undefined)
+            return undefined;
+        if (e.needsHuman === true)
+            return undefined;
+        if (e.status !== "notified" && e.status !== "arrived")
+            return undefined;
+        e.status = "settled";
+        e.settledAt = this.now();
+        this.save();
+        return e;
+    }
+    /** 撤销（任何时候可撤 —— 护栏④）。 */
+    revoke(id) {
+        const e = this.getEntrustment(id);
+        if (e === undefined || e.status === "settled" || e.status === "revoked")
+            return undefined;
+        e.status = "revoked";
+        e.revokedAt = this.now();
+        this.save();
+        return e;
+    }
+    /**
+     * 标记「需人决策」（human-gated）。
+     *
+     * 记录**原因**；托付**不**被结账（保持 `arrived`/`notified`）→ 可查、可继续。
+     */
+    markNeedsHuman(id, reason) {
+        const e = this.getEntrustment(id);
+        if (e === undefined)
+            return undefined;
+        e.needsHuman = true;
+        e.humanReason = reason;
+        this.save();
+        return e;
+    }
+    /** 本 agent id（事件流用）。 */
+    get agentId() {
+        return this.ownerAgentId;
+    }
+}

package/build/src/types.js

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

package/daemon/launchd.plist

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!--
+  pi-proactive 常驻值班进程（macOS launchd LaunchAgent）。
+
+  **模板文件**：双下划线包裹的大写占位符由 `pi-proactive/tools/daemon-install.sh` 渲染
+  （节点路径 / 值班脚本路径 / agentDir / 稳定身份 / 日志目录）。
+
+  为什么用 launchd 而不是 cron（任务卡 §2①）：
+  - cron 的最小粒度是 1 分钟，且**没有崩溃自愈**；launchd 有 `KeepAlive`（进程退出即拉起）→ 崩溃重启是内建的；
+  - cron 不带环境变量语义（要绕 shell 脚本传身份）；launchd 的 `EnvironmentVariables` 是结构化的；
+  - 日志由 `StandardOutPath` / `StandardErrorPath` 落盘 → 可被巡检读。
+
+  成本硬约束：这里的 `PI_PROACTIVE_DAEMON_DRY_RUN=1` 与配置里的 `enabled=false`（默认）
+  一起保证**装上不等于花钱**。
+-->
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>__LABEL__</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>/bin/bash</string>
+		<string>__RUNNER__</string>
+	</array>
+	<key>RunAtLoad</key>
+	<true/>
+	<key>KeepAlive</key>
+	<true/>
+	<key>ThrottleInterval</key>
+	<integer>10</integer>
+	<key>ProcessType</key>
+	<string>Background</string>
+	<key>WorkingDirectory</key>
+	<string>__PKG_ROOT__</string>
+	<key>EnvironmentVariables</key>
+	<dict>
+		<key>PI_PROACTIVE_AGENT_ID</key>
+		<string>__AGENT_ID__</string>
+		<key>PI_PROACTIVE_DAEMON_DRY_RUN</key>
+		<string>1</string>
+	</dict>
+	<key>StandardOutPath</key>
+	<string>__LOG_DIR__/daemon.out.log</string>
+	<key>StandardErrorPath</key>
+	<string>__LOG_DIR__/daemon.err.log</string>
+</dict>
+</plist>

package/daemon/pi-proactive-daemon.service

@@ -0,0 +1,29 @@
+# pi-proactive 常驻值班进程（Linux systemd --user 单元）
+#
+# **模板文件**：双下划线包裹的大写占位符由 `pi-proactive/tools/daemon-install.sh` 渲染
+# （节点路径 / 值班脚本路径 / agentDir / 稳定身份）。
+#
+# 为什么用 systemd --user 而不是 cron（任务卡 §2①）：
+# - `Restart=always` → 崩溃自启是内建的（cron 没有）；
+# - `Environment=` → 稳定身份（`PI_PROACTIVE_AGENT_ID`）跨重启连续；
+# - `KillSignal=SIGTERM` + `TimeoutStopSec` → 停止时给值班进程时间写交班摘要再退出。
+#
+# 成本硬约束：`PI_PROACTIVE_DAEMON_DRY_RUN=1` + 配置里的 `enabled=false`（默认）
+# 一起保证**装上不等于花钱**。
+[Unit]
+Description=pi-proactive 常驻值班进程（7x24 数字员工）
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=/bin/bash __RUNNER__
+WorkingDirectory=__PKG_ROOT__
+Environment=PI_PROACTIVE_AGENT_ID=__AGENT_ID__
+Environment=PI_PROACTIVE_DAEMON_DRY_RUN=1
+Restart=always
+RestartSec=5
+KillSignal=SIGTERM
+TimeoutStopSec=20
+
+[Install]
+WantedBy=default.target

package/daemon/run-daemon.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+
+# pi-proactive 常驻助理的**保活监督器**（supervisor）。
+#
+# 角色：**同时**充当两个宿主里的「保活容器」——
+#   ① herdr 宿主：助理跑在 herdr pane 里（纯 headless：无 TUI、不抢 stdin）；
+#   ② 系统宿主：launchd / systemd --user 单元跑的就是这个脚本。
+# 两者**跑的是同一个脚本** → 谁先拿到「值班锁」谁当值班进程，另一个转为待命。
+#
+# 为什么必须这样（形态选型 §2.5）：
+#   - 「用 herdr 工具」≠「有常驻」：herdr server 挂了 / pane 被回收 → 助理就没了；
+#   - 所以：**任何一边的宿主没了，另一边立刻接管**（助理不会随宿主一起消失）；
+#   - 这就是 §2.5 要求的「server 挂 → 助理可判定的降级」——降级目标 = 自带 daemon。
+#
+# 判定（**可判定**，不猜）：
+#   - 心跳新鲜（< STALE_MS）→ 已有实例在值班 → **不重复拉起**（避免双开 → 避免重复打扰）；
+#   - 心跳陈旧/缺失 → 抢 `daemon.lock`（mkdir 原子锁）→ 拿到锁的成为值班进程。
+#
+# 模板文件：双下划线包裹的大写占位符由 `pi-proactive/tools/daemon-install.sh` 渲染。
+set -uo pipefail
+
+NODE_BIN="__NODE__"
+DAEMON_TS="__DAEMON_TS__"
+AGENT_DIR="__AGENT_DIR__"
+AGENT_ID="__AGENT_ID__"
+LOG_DIR="__LOG_DIR__"
+
+export PI_PROACTIVE_AGENT_ID="${AGENT_ID}"
+
+DAEMON_DIR="${AGENT_DIR}/proactive/daemon"
+HEARTBEAT_FILE="${DAEMON_DIR}/heartbeat.json"
+LOCK_DIR="${DAEMON_DIR}/daemon.lock"
+# 心跳周期 5s（src/daemon.ts 的 HEARTBEAT_INTERVAL_MS）→ 20s 还没更新即判定「没在跑」。
+STALE_MS=20000
+
+mkdir -p "${LOG_DIR}" 2>/dev/null || true
+
+# 心跳是否新鲜（= 已经有实例在值班）。
+heartbeat_fresh() {
+	[ -f "${HEARTBEAT_FILE}" ] || return 1
+	local ts now
+	ts="$("${NODE_BIN}" -e '
+const fs=require("fs");
+try{const j=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));console.log(String(j.ts??""))}catch{console.log("")}' "${HEARTBEAT_FILE}" 2>/dev/null)"
+	[ -n "${ts}" ] || return 1
+	now="$(date +%s000)"
+	[ $(( now - ts )) -lt ${STALE_MS} ]
+}
+
+# 抢值班锁（mkdir 是原子的 → 两个监督器同时启动也只有一个能当值班进程）。
+acquire_lock() {
+	if mkdir "${LOCK_DIR}" 2>/dev/null; then
+		printf '%s' "$$" >"${LOCK_DIR}/pid" 2>/dev/null || true
+		return 0
+	fi
+	# 锁可能是上次崩溃留下的 → 锁里的 pid 不在了就清掉重抢。
+	local owner=""
+	owner="$(cat "${LOCK_DIR}/pid" 2>/dev/null || true)"
+	if [ -n "${owner}" ] && kill -0 "${owner}" 2>/dev/null; then
+		return 1
+	fi
+	rm -rf "${LOCK_DIR}" 2>/dev/null || true
+	if mkdir "${LOCK_DIR}" 2>/dev/null; then
+		printf '%s' "$$" >"${LOCK_DIR}/pid" 2>/dev/null || true
+		return 0
+	fi
+	return 1
+}
+
+while true; do
+	if heartbeat_fresh; then
+		# 已有实例在值班（多半是另一个宿主里的那个）→ 待命，不重复拉起。
+		sleep 3
+		continue
+	fi
+	if acquire_lock; then
+		"${NODE_BIN}" --experimental-strip-types "${DAEMON_TS}" --agent-dir "${AGENT_DIR}" \
+			>>"${LOG_DIR}/daemon.out.log" 2>>"${LOG_DIR}/daemon.err.log"
+		# 值班进程退出 → 释放锁，稍后重试（崩溃自愈）。
+		rm -rf "${LOCK_DIR}" 2>/dev/null || true
+	fi
+	sleep 3
+done

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,65 @@
+// 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 format = `import { Format } from "typebox/format"`;
+    const guard = `import { Guard } from "typebox/guard"`;
+    return [...context, hashing, format, 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;