@feng0531/dsh-execution-bus 0.12.0 → 1.0.0

package/dist/diagnostics.d.ts

@@ -1,41 +0,0 @@
-export type TraceStage = "accepted" | "started" | "cancel_requested" | "terminal" | "returned" | "job_created" | "job_released" | "job_error" | "reused" | "unique_reused";
-export interface Trace {
-    operation: number;
-    stage: TraceStage;
-    elapsedMs: number;
-}
-/** In-memory numeric metadata only: never accepts request/session strings, input, output or error text. */
-export declare class Diagnostics {
-    private next;
-    private events;
-    private cursor;
-    private size;
-    private counts;
-    begin(): {
-        operation: number;
-        at: number;
-    };
-    record(context: {
-        operation: number;
-        at: number;
-    }, stage: TraceStage): void;
-    snapshot(): {
-        counts: {
-            accepted?: number | undefined;
-            started?: number | undefined;
-            cancel_requested?: number | undefined;
-            terminal?: number | undefined;
-            returned?: number | undefined;
-            job_created?: number | undefined;
-            job_released?: number | undefined;
-            job_error?: number | undefined;
-            reused?: number | undefined;
-            unique_reused?: number | undefined;
-        };
-        traces: {
-            operation: number;
-            stage: TraceStage;
-            elapsedMs: number;
-        }[];
-    };
-}

package/dist/diagnostics.js

@@ -1,32 +0,0 @@
-import { performance } from "node:perf_hooks";
-import { LIMITS } from "./limits.js";
-/** In-memory numeric metadata only: never accepts request/session strings, input, output or error text. */
-export class Diagnostics {
-    next = 0;
-    events = new Array(LIMITS.traceRingSize);
-    cursor = 0;
-    size = 0;
-    counts = {};
-    begin() {
-        return { operation: ++this.next, at: performance.now() };
-    }
-    record(context, stage) {
-        this.counts[stage] = (this.counts[stage] ?? 0) + 1;
-        this.events[this.cursor] = {
-            operation: context.operation,
-            stage,
-            elapsedMs: Math.max(0, performance.now() - context.at),
-        };
-        this.cursor = (this.cursor + 1) % LIMITS.traceRingSize;
-        this.size = Math.min(this.size + 1, LIMITS.traceRingSize);
-    }
-    snapshot() {
-        return {
-            counts: { ...this.counts },
-            traces: Array.from({ length: this.size }, (_, index) => ({
-                ...this.events[(this.cursor - this.size + LIMITS.traceRingSize + index) %
-                    LIMITS.traceRingSize],
-            })),
-        };
-    }
-}

package/dist/execution.d.ts

@@ -1,70 +0,0 @@
-import type { JobRegistry, JobId } from "@deepseek-ai/dsh-jobs";
-import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { RecordView, Event } from "./bus.js";
-import { Diagnostics } from "./diagnostics.js";
-export interface ExecutionAttachment {
-    done: Promise<RecordView>;
-    cancel(): void;
-}
-/** One host projection of a logical execution. The core completion remains authoritative. */
-export declare class ExecutionHandle {
-    private jobs;
-    private owner;
-    private execution;
-    private telemetry;
-    readonly completion: Promise<RecordView>;
-    readonly settled: Promise<void>;
-    readonly job: JobId;
-    private progressHandle?;
-    private trace;
-    constructor(jobs: JobRegistry, owner: SessionId, execution: ExecutionAttachment, telemetry?: Diagnostics);
-    requestCancel(): void;
-    progress(event: Event): void;
-    private absent;
-    private waitAndClean;
-    /** 等待宿主 Job 到达终态（离开 running/stopping）。 */
-    private awaitTerminal;
-    /** wait 失败后的有界恢复：清理已终态的 Job，但仍向上保留原始错误可见性。 */
-    private recoverOnWaitError;
-}
-export type ShutdownPhase = "open" | "stopping" | "draining" | "releasing" | "closed";
-/** Owns host projections and active deliveries, not a second execution state machine. */
-export declare class ExecutionOwner {
-    private handles;
-    private deliveries;
-    private closing?;
-    private telemetry;
-    create(key: string, jobs: JobRegistry, owner: SessionId, execution: ExecutionAttachment): ExecutionHandle;
-    diagnostics(): {
-        phase: ShutdownPhase;
-        activeProjections: number;
-        deliveries: number;
-        counts: {
-            accepted?: number | undefined;
-            started?: number | undefined;
-            cancel_requested?: number | undefined;
-            terminal?: number | undefined;
-            returned?: number | undefined;
-            job_created?: number | undefined;
-            job_released?: number | undefined;
-            job_error?: number | undefined;
-            reused?: number | undefined;
-            unique_reused?: number | undefined;
-        };
-        traces: {
-            operation: number;
-            stage: import("./diagnostics.js").TraceStage;
-            elapsedMs: number;
-        }[];
-    };
-    private currentPhase;
-    get phase(): ShutdownPhase;
-    get(key: string): ExecutionHandle | undefined;
-    add(key: string, handle: ExecutionHandle): void;
-    /** 拒绝关闭后或重复 key 的准入；create/add 共用这一道守卫。 */
-    private assertAdmittable;
-    /** 登记 handle，并在其结算后从表中移除该登记。 */
-    private attach;
-    track<T>(delivery: Promise<T>): Promise<T>;
-    close(drainCore: () => Promise<void>): Promise<void>;
-}

package/dist/execution.js

@@ -1,193 +0,0 @@
-import { setTimeout as pause } from "node:timers/promises";
-import { Diagnostics } from "./diagnostics.js";
-import { ERRORS } from "./error-codes.js";
-/** 把执行终态映射为宿主 Job 的结果状态。 */
-function jobOutcome(state) {
-    return {
-        status: state === "succeeded"
-            ? "completed"
-            : state === "cancelled"
-                ? "killed"
-                : "failed",
-        detail: state,
-    };
-}
-/** One host projection of a logical execution. The core completion remains authoritative. */
-export class ExecutionHandle {
-    jobs;
-    owner;
-    execution;
-    telemetry;
-    completion;
-    settled;
-    job;
-    progressHandle;
-    trace;
-    constructor(jobs, owner, execution, telemetry = new Diagnostics()) {
-        this.jobs = jobs;
-        this.owner = owner;
-        this.execution = execution;
-        this.telemetry = telemetry;
-        this.trace = telemetry.begin();
-        this.completion = execution.done;
-        const outcome = this.completion.then((v) => jobOutcome(v.state));
-        this.job = jobs.start({
-            kind: "execution-bus",
-            label: "萧何 / Xiao He",
-            owner,
-            run: (handle) => {
-                this.progressHandle = handle;
-                return { done: outcome, cancel: () => this.requestCancel() };
-            },
-        });
-        telemetry.record(this.trace, "job_created");
-        this.settled = this.waitAndClean();
-    }
-    requestCancel() {
-        this.execution.cancel();
-    }
-    progress(event) {
-        this.progressHandle?.updateProgress(event.type === "progress"
-            ? String(event.payload.percent) + "%"
-            : event.type);
-    }
-    absent(error) {
-        try {
-            return (error instanceof Error &&
-                error.message === "unknown job " + this.job &&
-                !this.jobs.list(this.owner).some((v) => v.id === this.job));
-        }
-        catch {
-            return false;
-        }
-    }
-    async waitAndClean() {
-        try {
-            await this.awaitTerminal();
-            this.jobs.remove(this.job, this.owner);
-            this.telemetry.record(this.trace, "job_released");
-        }
-        catch (error) {
-            this.telemetry.record(this.trace, "job_error");
-            await this.recoverOnWaitError(error);
-        }
-        finally {
-            this.progressHandle = undefined;
-        }
-    }
-    /** 等待宿主 Job 到达终态（离开 running/stopping）。 */
-    async awaitTerminal() {
-        for (;;) {
-            const view = await this.jobs.wait(this.job, 60000, this.owner);
-            if (view.status !== "running" && view.status !== "stopping")
-                return;
-        }
-    }
-    /** wait 失败后的有界恢复：清理已终态的 Job，但仍向上保留原始错误可见性。 */
-    async recoverOnWaitError(error) {
-        const alreadyRemoved = this.absent(error);
-        // 保留原执行结果，即便其调用者/owner 正在被释放。
-        await this.completion;
-        // Job 已不在列表时仅记录释放，不把 wait 错误视为未处理的清理失败。
-        if (alreadyRemoved) {
-            this.telemetry.record(this.trace, "job_released");
-            return;
-        }
-        for (let attempt = 0; attempt < 20; attempt++) {
-            try {
-                const view = this.jobs
-                    .list(this.owner)
-                    .find((v) => v.id === this.job && v.owner === this.owner);
-                if (!view) {
-                    this.telemetry.record(this.trace, "job_released");
-                    break;
-                }
-                if (view.status !== "running" && view.status !== "stopping") {
-                    this.jobs.remove(this.job, this.owner);
-                    this.telemetry.record(this.trace, "job_released");
-                    break;
-                }
-            }
-            catch {
-                break;
-            }
-            await pause(10);
-        }
-        throw error;
-    }
-}
-/** Owns host projections and active deliveries, not a second execution state machine. */
-export class ExecutionOwner {
-    handles = new Map();
-    deliveries = new Set();
-    closing;
-    telemetry = new Diagnostics();
-    create(key, jobs, owner, execution) {
-        this.assertAdmittable(key);
-        const handle = new ExecutionHandle(jobs, owner, execution, this.telemetry);
-        this.attach(key, handle);
-        return handle;
-    }
-    diagnostics() {
-        return {
-            ...this.telemetry.snapshot(),
-            phase: this.phase,
-            activeProjections: this.handles.size,
-            deliveries: this.deliveries.size,
-        };
-    }
-    currentPhase = "open";
-    get phase() {
-        return this.currentPhase;
-    }
-    get(key) {
-        return this.handles.get(key);
-    }
-    add(key, handle) {
-        this.assertAdmittable(key);
-        this.attach(key, handle);
-    }
-    /** 拒绝关闭后或重复 key 的准入；create/add 共用这一道守卫。 */
-    assertAdmittable(key) {
-        if (this.phase !== "open")
-            throw Error(ERRORS.CLOSED);
-        if (this.handles.has(key))
-            throw Error(ERRORS.DUPLICATE_EXECUTION_HANDLE);
-    }
-    /** 登记 handle，并在其结算后从表中移除该登记。 */
-    attach(key, handle) {
-        this.handles.set(key, handle);
-        const release = () => {
-            if (this.handles.get(key) === handle)
-                this.handles.delete(key);
-        };
-        void handle.settled.then(release, release);
-    }
-    track(delivery) {
-        this.deliveries.add(delivery);
-        const release = () => this.deliveries.delete(delivery);
-        void delivery.then(release, release);
-        return delivery;
-    }
-    close(drainCore) {
-        if (this.closing)
-            return this.closing;
-        this.currentPhase = "stopping";
-        let resolve, reject;
-        this.closing = new Promise((r, j) => {
-            resolve = r;
-            reject = j;
-        });
-        void (async () => {
-            const core = drainCore();
-            this.currentPhase = "draining";
-            await core;
-            await Promise.allSettled([...this.deliveries]);
-            this.currentPhase = "releasing";
-            await Promise.allSettled([...this.handles.values()].map((h) => h.settled));
-            this.handles.clear();
-            this.currentPhase = "closed";
-        })().then(resolve, reject);
-        return this.closing;
-    }
-}

package/dist/handlers.d.ts

@@ -1,25 +0,0 @@
-import type { Handler } from "./bus.js";
-/** 宿主工具转发 Handler 工厂：校验后把调用交回宿主工具管线执行。
- *  idempotent 由调用方按工具副作用显式声明；prepare 可补默认参数。 */
-export declare function hostToolHandler(toolName: string, opts: {
-    idempotent: boolean;
-    validate(input: Record<string, unknown>): void;
-    prepare?(input: Record<string, unknown>): Record<string, unknown>;
-    queue?: string;
-    maxConcurrency?: number;
-    resources?(input: Record<string, unknown>): readonly string[];
-    dedupe?: "payload";
-}): Handler;
-export declare const testHandler: Handler;
-/** 读取：无副作用，幂等，终态结果可复用；可按 payload 指纹做唯一任务。 */
-export declare const readHandler: Handler;
-/** 文件名搜索：只读，幂等，终态结果可复用；搜索基数由宿主工具限制。 */
-export declare const globHandler: Handler;
-/** 内容搜索：只读，幂等，终态结果可复用；匹配上限由宿主工具限制。 */
-export declare const grepHandler: Handler;
-/** 写入：有副作用，非幂等，终态结果不可复用。 */
-export declare const writeHandler: Handler;
-/** 编辑：有副作用，非幂等，终态结果不可复用。 */
-export declare const editHandler: Handler;
-/** 命令执行：有副作用，非幂等，终态结果不可复用；后台模式返回 Job ID 不等于完成。 */
-export declare const pwshHandler: Handler;

package/dist/handlers.js

@@ -1,194 +0,0 @@
-import { setTimeout } from "node:timers/promises";
-import { ERRORS } from "./error-codes.js";
-import { HANDLER_LIMITS } from "./product.js";
-/** 宿主工具转发 Handler 工厂：校验后把调用交回宿主工具管线执行。
- *  idempotent 由调用方按工具副作用显式声明；prepare 可补默认参数。 */
-export function hostToolHandler(toolName, opts) {
-    // toolName 只表达意图；实际宿主工具已由宿主层按 handler 名绑定到 capability。
-    void toolName;
-    return {
-        idempotent: opts.idempotent,
-        queue: opts.queue,
-        maxConcurrency: opts.maxConcurrency,
-        resources: opts.resources,
-        dedupe: opts.dedupe,
-        validate: opts.validate,
-        async run(input, ctx) {
-            if (!ctx.invoke)
-                throw Error(ERRORS.HOST_CAPABILITY_REQUIRED);
-            return ctx.invoke(opts.prepare ? opts.prepare(input) : input, ctx.signal);
-        },
-    };
-}
-export const testHandler = {
-    idempotent: true,
-    queue: "diagnostic",
-    validate(input) {
-        if (Object.keys(input).some((k) => !["delayMs", "fail"].includes(k)) ||
-            !Number.isSafeInteger(input.delayMs) ||
-            Number(input.delayMs) < 0 ||
-            Number(input.delayMs) > HANDLER_LIMITS.diagnosticDelayMs ||
-            typeof input.fail !== "boolean")
-            throw Error(ERRORS.INVALID_TEST_INPUT);
-    },
-    async run(input, ctx) {
-        for (let i = 1; i <= 5; i++) {
-            await setTimeout(Number(input.delayMs) / 5, undefined, {
-                signal: ctx.signal,
-            });
-            ctx.progress(i, i * 20);
-        }
-        if (input.fail)
-            throw Error(ERRORS.CONTROLLED_FAILURE);
-        return { ok: true };
-    },
-};
-function validateRead(input) {
-    if (Object.keys(input).some((k) => !["file_path", "offset", "limit"].includes(k)) ||
-        typeof input.file_path !== "string" ||
-        !input.file_path ||
-        input.file_path.length > HANDLER_LIMITS.readPathChars)
-        throw Error(ERRORS.INVALID_READ_INPUT);
-    for (const k of ["offset", "limit"])
-        if (input[k] !== undefined &&
-            (!Number.isSafeInteger(input[k]) || Number(input[k]) < 1))
-            throw Error(ERRORS.INVALID_READ_INPUT);
-    if (Number(input.limit ?? HANDLER_LIMITS.readLines) > HANDLER_LIMITS.readLines)
-        throw Error(ERRORS.READ_LIMIT);
-}
-function validateEdit(input) {
-    if (Object.keys(input).some((k) => !["file_path", "old_string", "new_string", "replace_all"].includes(k)) ||
-        typeof input.file_path !== "string" ||
-        !input.file_path ||
-        input.file_path.length > HANDLER_LIMITS.readPathChars ||
-        typeof input.old_string !== "string" ||
-        typeof input.new_string !== "string" ||
-        (input.replace_all !== undefined && typeof input.replace_all !== "boolean"))
-        throw Error(ERRORS.INVALID_EDIT_INPUT);
-}
-/** 同一路径的文件写入/编辑互斥；路径按调用原文作为资源键（不做跨平台归一化）。 */
-function fileResource(input) {
-    return ["file:" + String(input.file_path)];
-}
-/** 读取：无副作用，幂等，终态结果可复用；可按 payload 指纹做唯一任务。 */
-export const readHandler = hostToolHandler("read", {
-    idempotent: true,
-    queue: "fs",
-    dedupe: "payload",
-    validate: validateRead,
-    prepare: (input) => ({
-        ...input,
-        limit: input.limit ?? HANDLER_LIMITS.readLines,
-    }),
-});
-function validateGlob(input) {
-    if (Object.keys(input).some((k) => !["pattern", "path"].includes(k)) ||
-        typeof input.pattern !== "string" ||
-        input.pattern.trim().length === 0 ||
-        (input.path !== undefined &&
-            (typeof input.path !== "string" || input.path.trim().length === 0)))
-        throw Error(ERRORS.INVALID_GLOB_INPUT);
-}
-/** 文件名搜索：只读，幂等，终态结果可复用；搜索基数由宿主工具限制。 */
-export const globHandler = hostToolHandler("glob", {
-    idempotent: true,
-    queue: "fs",
-    dedupe: "payload",
-    validate: validateGlob,
-});
-function validateGrep(input) {
-    if (Object.keys(input).some((k) => !["pattern", "path", "include"].includes(k)) ||
-        typeof input.pattern !== "string" ||
-        input.pattern.length === 0 ||
-        (input.path !== undefined &&
-            (typeof input.path !== "string" || input.path.trim().length === 0)))
-        throw Error(ERRORS.INVALID_GREP_INPUT);
-    if (input.include === undefined)
-        return;
-    const include = input.include;
-    if (typeof include !== "string" || include.trim().length === 0)
-        throw Error(ERRORS.INVALID_GREP_INPUT);
-    // 与宿主 grep 契约一致：只接受单个正向 glob，不支持取反或顶层逗号列表。
-    if (include.startsWith("!"))
-        throw Error(ERRORS.INVALID_GREP_INPUT);
-    let braceDepth = 0;
-    for (const char of include) {
-        if (char === "{")
-            braceDepth++;
-        else if (char === "}")
-            braceDepth = Math.max(0, braceDepth - 1);
-        else if (char === "," && braceDepth === 0)
-            throw Error(ERRORS.INVALID_GREP_INPUT);
-    }
-}
-/** 内容搜索：只读，幂等，终态结果可复用；匹配上限由宿主工具限制。 */
-export const grepHandler = hostToolHandler("grep", {
-    idempotent: true,
-    queue: "fs",
-    dedupe: "payload",
-    validate: validateGrep,
-});
-function validateWrite(input) {
-    if (Object.keys(input).some((k) => !["file_path", "content"].includes(k)) ||
-        typeof input.file_path !== "string" ||
-        !input.file_path ||
-        input.file_path.length > HANDLER_LIMITS.readPathChars ||
-        typeof input.content !== "string")
-        throw Error(ERRORS.INVALID_WRITE_INPUT);
-}
-/** 写入：有副作用，非幂等，终态结果不可复用。 */
-export const writeHandler = hostToolHandler("write", {
-    idempotent: false,
-    queue: "fs",
-    resources: fileResource,
-    validate: validateWrite,
-});
-/** 编辑：有副作用，非幂等，终态结果不可复用。 */
-export const editHandler = hostToolHandler("edit", {
-    idempotent: false,
-    queue: "fs",
-    resources: fileResource,
-    validate: validateEdit,
-});
-/** 与宿主 pwsh 工具一致的提权目标；沙箱组合未提供提权面时由宿主拒绝。 */
-const PWSH_ESCALATION_TARGETS = Object.freeze([
-    "workspace-write",
-    "danger-full-access",
-]);
-function validatePwsh(input) {
-    if (Object.keys(input).some((k) => ![
-        "description",
-        "command",
-        "timeoutMs",
-        "workdir",
-        "run_in_background",
-        "sandbox_permissions",
-        "justification",
-    ].includes(k)) ||
-        typeof input.command !== "string" ||
-        input.command.trim().length === 0 ||
-        typeof input.description !== "string" ||
-        input.description.trim().length === 0 ||
-        (input.timeoutMs !== undefined &&
-            (!Number.isFinite(input.timeoutMs) || Number(input.timeoutMs) <= 0)) ||
-        (input.workdir !== undefined && typeof input.workdir !== "string") ||
-        (input.run_in_background !== undefined &&
-            typeof input.run_in_background !== "boolean"))
-        throw Error(ERRORS.INVALID_PWSH_INPUT);
-    const permissions = input.sandbox_permissions, justification = input.justification;
-    if ((permissions !== undefined && justification === undefined) ||
-        (justification !== undefined && permissions === undefined) ||
-        (permissions !== undefined &&
-            (typeof permissions !== "string" ||
-                !PWSH_ESCALATION_TARGETS.includes(permissions))) ||
-        (justification !== undefined &&
-            (typeof justification !== "string" ||
-                justification.trim().length === 0)))
-        throw Error(ERRORS.INVALID_PWSH_INPUT);
-}
-/** 命令执行：有副作用，非幂等，终态结果不可复用；后台模式返回 Job ID 不等于完成。 */
-export const pwshHandler = hostToolHandler("pwsh", {
-    idempotent: false,
-    queue: "command",
-    validate: validatePwsh,
-});

package/dist/json.d.ts

@@ -1,4 +0,0 @@
-/** Strict JSON tree validation before serialization, cloning or recursive freezing. */
-export declare function assertJson(value: unknown, depth?: number, active?: Set<object>, budget?: {
-    left: 65536;
-}): void;

package/dist/json.js

@@ -1,46 +0,0 @@
-import { ERRORS } from "./error-codes.js";
-import { LIMITS } from "./limits.js";
-/** Strict JSON tree validation before serialization, cloning or recursive freezing. */
-export function assertJson(value, depth = 0, active = new Set(), budget = { left: LIMITS.jsonNodeBudget }) {
-    if (--budget.left < 0 || depth > LIMITS.jsonMaxDepth)
-        throw Error(ERRORS.JSON_LIMIT);
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return;
-    if (typeof value === "number" &&
-        Number.isFinite(value) &&
-        !Object.is(value, -0))
-        return;
-    if (typeof value !== "object" || value === null)
-        throw Error(ERRORS.INVALID_JSON);
-    if (active.has(value))
-        throw Error(ERRORS.CYCLIC_JSON);
-    const array = Array.isArray(value);
-    if (array && Object.getPrototypeOf(value) !== Array.prototype)
-        throw Error(ERRORS.INVALID_JSON_ARRAY);
-    if (!array &&
-        Object.getPrototypeOf(value) !== Object.prototype &&
-        Object.getPrototypeOf(value) !== null)
-        throw Error(ERRORS.INVALID_JSON_OBJECT);
-    active.add(value);
-    try {
-        const keys = Reflect.ownKeys(value);
-        if (array && keys.length !== value.length + 1)
-            throw Error(ERRORS.INVALID_JSON_ARRAY);
-        for (const key of keys) {
-            if (array && key === "length")
-                continue;
-            if (typeof key !== "string")
-                throw Error(ERRORS.INVALID_JSON_KEY);
-            if (array &&
-                (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length))
-                throw Error(ERRORS.INVALID_JSON_ARRAY);
-            const descriptor = Object.getOwnPropertyDescriptor(value, key);
-            if (!descriptor.enumerable || !("value" in descriptor))
-                throw Error(ERRORS.INVALID_JSON_PROPERTY);
-            assertJson(descriptor.value, depth + 1, active, budget);
-        }
-    }
-    finally {
-        active.delete(value);
-    }
-}

package/dist/limits.d.ts

@@ -1,20 +0,0 @@
-export declare const LIMITS: Readonly<{
-    /** 单条协议消息 JSON 的最大字节数（parse 拒绝更大消息）。 */
-    messageMaxBytes: 16384;
-    /** messageId / requestId 的最大字符数。 */
-    idMaxLength: 128;
-    /** messageId / requestId 的合法字符集。 */
-    idPattern: RegExp;
-    /** 单个逻辑执行所记账的消息条数上限（含首次、重复请求与查询）。 */
-    messageAccountLimit: 128;
-    /** 单个执行可同时附着的观察者上限。 */
-    waiterLimit: 32;
-    /** inspect() 单次返回的任务元数据条数上限。 */
-    inspectTaskLimit: 50;
-    /** 严格 JSON 树的最大嵌套深度。 */
-    jsonMaxDepth: 64;
-    /** 严格 JSON 树可访问的节点总数预算。 */
-    jsonNodeBudget: 65536;
-    /** 诊断环形轨迹的槽位数量。 */
-    traceRingSize: 128;
-}>;

package/dist/limits.js

@@ -1,23 +0,0 @@
-/** 集中定义跨模块共享的固定数值上限。内部实现约束，非用户可配置项。
- *  数值相同时语义依然独立，勿为了“省一个常量”而合并。 */
-const ID_MAX_LENGTH = 128;
-export const LIMITS = Object.freeze({
-    /** 单条协议消息 JSON 的最大字节数（parse 拒绝更大消息）。 */
-    messageMaxBytes: 16384,
-    /** messageId / requestId 的最大字符数。 */
-    idMaxLength: ID_MAX_LENGTH,
-    /** messageId / requestId 的合法字符集。 */
-    idPattern: new RegExp(`^[a-zA-Z0-9_.:-]{1,${ID_MAX_LENGTH}}$`),
-    /** 单个逻辑执行所记账的消息条数上限（含首次、重复请求与查询）。 */
-    messageAccountLimit: 128,
-    /** 单个执行可同时附着的观察者上限。 */
-    waiterLimit: 32,
-    /** inspect() 单次返回的任务元数据条数上限。 */
-    inspectTaskLimit: 50,
-    /** 严格 JSON 树的最大嵌套深度。 */
-    jsonMaxDepth: 64,
-    /** 严格 JSON 树可访问的节点总数预算。 */
-    jsonNodeBudget: 65536,
-    /** 诊断环形轨迹的槽位数量。 */
-    traceRingSize: 128,
-});