@logictan/dsh-config-manager 0.1.60

package/lib/core/rollback.d.ts

@@ -0,0 +1,12 @@
+import type { ConfigAdapter, HostContext, RollbackReport, Snapshot, SnapshotStore } from './types.ts';
+export interface RollbackOptions {
+    ctx: HostContext;
+    snapshot: Snapshot;
+    store?: SnapshotStore;
+    adapters?: ConfigAdapter[];
+    /** 回滚 WAL（Phase 3）：每补偿完一条 entry 调用，供 Coordinator 记录 rollback.entryDone；
+     *   crash during rollback 后 reconcile 从 WAL 判定已补偿/未补偿，避免盲目从头重做。 */
+    entryDone?: (entryIndex: number) => Promise<void>;
+}
+/** 回滚：逆序补偿全部条目；返回诚实报告（full / partial） */
+export declare function rollback(opts: RollbackOptions): Promise<RollbackReport>;

package/lib/core/rollback.js

@@ -0,0 +1,145 @@
+/**
+ * Rollback（规范 §17 / 设计 §8.2）：导入失败时逆序执行快照条目的补偿动作。
+ *
+ * 诚实原则：
+ *  - 尽力回滚：单项失败不停止其余补偿，最终如实报告 full / partial；
+ *  - credential 值 DSH 永不回读 → existed=true 的凭据无法自动恢复原值，
+ *    如实标记 failed + manualHint（人工补录）；
+ *  - settings 回滚仍走 expectedRevision 乐观锁，避免覆盖导入后用户的新修改。
+ */
+import { resolveFileTarget } from './backup.js';
+import { msgOf } from './messages.js';
+/** 逆序补偿单条快照条目；返回 null=成功，否则为失败原因 */
+async function compensateOne(entry, ctx, store) {
+    switch (entry.kind) {
+        case 'settingsNamespace': {
+            try {
+                if (!entry.existed) {
+                    // 原目标不存在该 namespace：若导入已创建它，DSH settings 无删除语义 → 无法恢复「不存在」
+                    let current = null;
+                    try {
+                        current = await ctx.settings.describe(entry.ref);
+                    }
+                    catch {
+                        current = null;
+                    }
+                    if (current === null)
+                        return null; // 本来就没有且未创建 → 无需恢复
+                    return {
+                        reason: msgOf(ctx)('rollback.ns.createdNoDelete'),
+                        manualHint: msgOf(ctx)('rollback.ns.manualHint', { ref: entry.ref }),
+                    };
+                }
+                // 用当前 revision 作乐观锁基准：读时即锁，冲突则如实失败（不覆盖并发修改）
+                const current = await ctx.settings.describe(entry.ref);
+                await ctx.settings.replace(entry.ref, entry.before, current.revision);
+                return null;
+            }
+            catch (err) {
+                return { reason: err instanceof Error ? err.message : String(err), manualHint: msgOf(ctx)('rollback.ns.conflictHint', { ref: entry.ref }) };
+            }
+        }
+        case 'credential': {
+            if (entry.existed) {
+                // 值不可回读：无法自动恢复原值
+                return {
+                    reason: msgOf(ctx)('rollback.cred.noReadback'),
+                    manualHint: msgOf(ctx)('rollback.cred.manualHint', { ref: entry.ref }),
+                };
+            }
+            try {
+                await ctx.credentials.unset(entry.ref);
+                return null;
+            }
+            catch (err) {
+                return { reason: err instanceof Error ? err.message : String(err) };
+            }
+        }
+        case 'patchLine': {
+            try {
+                // 引擎只管理 profile 的 cordis.patch.yml（backup.ts 的 patchLine 快照只记 lineId 作 ref，
+                // 不含文件编码）——回滚固定写回该文件；切勿把 lineId 当文件名（否则 patchPath 抛「仅支持管理」）。
+                const file = 'cordis.patch.yml';
+                const lineId = entry.ref;
+                await ctx.patchFile.applyPatchChanges(file, [
+                    { lineId, raw: entry.before, action: entry.before === null ? 'remove' : 'update' },
+                ]);
+                return null;
+            }
+            catch (err) {
+                return { reason: err instanceof Error ? err.message : String(err), manualHint: msgOf(ctx)('rollback.patch.manualHint', { ref: entry.ref }) };
+            }
+        }
+        case 'file': {
+            try {
+                const abs = resolveFileTarget(ctx, entry.adapter, entry.ref);
+                if (entry.existed && entry.copiedTo && store) {
+                    const data = await store.readBlob(entry.snapshotId ?? '', entry.copiedTo);
+                    await ctx.fs.writeFile(abs, data);
+                }
+                else if (!entry.existed) {
+                    // 原文件不存在 → 删除导入写入的文件
+                    if (await ctx.fs.exists(abs))
+                        await ctx.fs.remove(abs);
+                }
+                return null;
+            }
+            catch (err) {
+                return { reason: err instanceof Error ? err.message : String(err), manualHint: msgOf(ctx)('rollback.file.manualHint', { ref: entry.ref }) };
+            }
+        }
+        case 'workspaceRecord': {
+            try {
+                if (entry.before === null) {
+                    await ctx.workspace.removeRecord?.(entry.ref);
+                }
+                else {
+                    await ctx.workspace.writeRecord(entry.before);
+                }
+                return null;
+            }
+            catch (err) {
+                return { reason: err instanceof Error ? err.message : String(err), manualHint: msgOf(ctx)('rollback.workspace.manualHint', { ref: entry.ref }) };
+            }
+        }
+        default:
+            return { reason: msgOf(ctx)('rollback.unknownEntry', { kind: entry.kind }) };
+    }
+}
+/** 回滚：逆序补偿全部条目；返回诚实报告（full / partial） */
+export async function rollback(opts) {
+    const { ctx, snapshot, store, adapters, entryDone } = opts;
+    const restored = [];
+    const failed = [];
+    // 逆序遍历；adapter 自带的 rollback? 优先，否则引擎通用补偿
+    const entries = [...snapshot.entries].reverse();
+    for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index];
+        const adapter = adapters?.find((a) => a.id === entry.adapter);
+        let error = null;
+        if (adapter?.rollback) {
+            try {
+                await adapter.rollback([entry], ctx);
+            }
+            catch (err) {
+                error = { reason: err instanceof Error ? err.message : String(err) };
+            }
+        }
+        else {
+            error = await compensateOne(entry, ctx, store);
+        }
+        // 回滚 WAL：每补偿一项记 entryDone（crash 后可判定进度）
+        try {
+            await opts.entryDone?.(index);
+        }
+        catch { /* WAL 写失败不阻断回滚（best-effort） */ }
+        if (error === null) {
+            restored.push(`${entry.adapter}:${entry.ref}`);
+        }
+        else {
+            failed.push({ item: `${entry.adapter}:${entry.ref}`, reason: error.reason, manualHint: error.manualHint });
+        }
+    }
+    return { full: failed.length === 0, restored, failed };
+}
+//# sourceMappingURL=rollback.js.map

package/lib/core/run-registry.d.ts

@@ -0,0 +1,85 @@
+import type { MsgFunc } from './messages.ts';
+/** run 类型：导出 / 导入 / 自动同步 / 一键同步逐项应用 / 定时备份 / 快照恢复 / 配置档案切换 / recovery 恢复。 */
+export type RunKind = 'export' | 'import' | 'autosync' | 'sync-apply' | 'backup-schedule' | 'restore' | 'profile-switch' | 'recovery';
+/** run 状态：进行中 / 完成 / 失败。 */
+export type RunStatus = 'running' | 'done' | 'failed';
+/** 单个 run 的实时状态（/progress 返回体；纯 JSON 可序列化）。 */
+export interface RunState {
+    /** 不可猜测的 run id（32 hex 字符）。 */
+    runId: string;
+    kind: RunKind;
+    status: RunStatus;
+    /** 当前分区（adapter id 或导入阶段名）；无则 null。 */
+    section: string | null;
+    /** 分区总数（导出 = 选中分区数；导入无此语义 = null）。 */
+    sectionTotal: number | null;
+    /** 已完成的内部计数（导出 = 当前分区序号；导入 = 已处理计划项数）。 */
+    item: number | null;
+    /** 内部计数总数（导出 = 分区总数；导入 = 计划项总数）。 */
+    itemTotal: number | null;
+    /** 非敏感进度摘要（当前分区 / 当前计划项 id）。 */
+    detail: string | null;
+    /** 执行日志行（导入为逐计划项操作 + 子进程命令；append-only，封顶 MAX_RUN_LOG_LINES）。
+     * 只存非敏感文本（命令/操作摘要），绝不写入密钥、密码、秘密补录值。 */
+    log: string[];
+    /** 完成时的业务结果（仅 JSON 可序列化、不含秘密值）。 */
+    result?: unknown;
+    /** 失败时的错误消息（非敏感）。 */
+    error?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/** 单个 run 执行日志的行数上限（防无限增长；截断时保留最新行）。 */
+export declare const MAX_RUN_LOG_LINES = 500;
+/** 进行中同 kind 已有 run 时注册被拒（宿主路由 → 409）。 */
+export declare class RunConflictError extends Error {
+    /** 已在进行中的 run id（供客户端定位既有任务）。 */
+    readonly runId: string;
+    constructor(runId: string, kind: RunKind, msg?: MsgFunc);
+}
+/** 完成/失败后的默认保留时长（30 分钟）。 */
+export declare const DEFAULT_RUN_RETENTION_MS: number;
+export interface RunRegistryOptions {
+    /** 完成/失败后保留时长（默认 30 分钟）；超期 run 在下次访问时清理。 */
+    retentionMs?: number;
+    /** 时间源（测试注入）。 */
+    now?: () => number;
+    /** 消息翻译器（缺省 zh；冲突错误文案随应用语言）。 */
+    msg?: MsgFunc;
+}
+/**
+ * 内存 run 注册表。Node 单线程 + 同步 Map 读写，无并发竞争；
+ * 所有公开读方法返回状态副本，防止外部直接篡改内部状态。
+ */
+export declare class RunRegistry {
+    private readonly runs;
+    private readonly retentionMs;
+    private readonly now;
+    private readonly msg;
+    constructor(opts?: RunRegistryOptions);
+    /** 注册新 run；同 kind 已有 running 时抛 RunConflictError。 */
+    register(kind: RunKind): RunState;
+    /** 更新进度；run 不存在返回 undefined；已完成/失败后的晚到更新被忽略（防御异步回调竞态）。 */
+    update(runId: string, patch: Partial<Pick<RunState, 'section' | 'sectionTotal' | 'item' | 'itemTotal' | 'detail'>>): RunState | undefined;
+    /**
+     * 追加一行执行日志（导入逐计划项操作 / 子进程命令）；run 不存在返回 undefined，
+     * 已完成/失败后的晚到追加被忽略（防御异步回调竞态）。行数封顶 MAX_RUN_LOG_LINES，
+     * 超限时截断保留最新行。
+     *
+     * **不可变写入（性能正确性关键）**：每次 append 生成新数组（push + splice 会原地
+     * mutation —— /progress 轮询返回的 RunState.log 与浏览器侧 store 共享同一引用，
+     * 行数封顶后长度恒定，React memo 按引用/长度比较将无法感知新行，日志面板冻结）。
+     * 调用方（mapRunProgress → ImportLogPanel）据此以「数组引用变化」判断有新输出。
+     */
+    appendLog(runId: string, line: string): RunState | undefined;
+    /** 读单个 run；超过保留期或不存在返回 undefined。 */
+    get(runId: string): RunState | undefined;
+    /** 列出活跃（running）run（刷新恢复时经 /runs 重订阅用）。 */
+    listActive(): RunState[];
+    /** 标记完成并写入业务结果；run 不存在返回 undefined。 */
+    finish(runId: string, result: unknown): RunState | undefined;
+    /** 标记失败并写入错误消息；run 不存在返回 undefined。 */
+    fail(runId: string, error: string): RunState | undefined;
+    /** 惰性清理：超过保留期的 run（含长期 running 的僵死任务）全部移除。 */
+    private prune;
+}

package/lib/core/run-registry.js

@@ -0,0 +1,157 @@
+/**
+ * Host 端 run 注册表（m1）：记录导出/导入任务的运行状态与真实进度。
+ *
+ * 浏览器侧通过 `/api/dsh-config-manager/progress?runId=…` 与
+ * `/api/dsh-config-manager/runs` 轮询/恢复进度（m2 store 刷新恢复、m3 进度 UI
+ * 消费）；本模块是 Host 侧的单一事实源，不依赖任何 DSH 运行时服务。
+ *
+ * 安全纪律：
+ *  - runId 由 crypto.randomBytes(16) 生成（32 hex 字符），不可猜测；
+ *  - RunState 只存非敏感摘要（分区/计数/详情文案），绝不写入密钥、密码、
+ *    秘密补录值或任何敏感内容；
+ *  - result 只存可 JSON 序列化的业务结果（导出为 { zipPath, manifest, report }，
+ *    导入为 ImportResult），不含秘密值。
+ *
+ * 生命周期：register（running）→ update（进度）→ finish（done+result）/
+ * fail（failed+error）；超过保留期（默认 30 分钟）的 run 在任意读操作时惰性清理。
+ * 并发纪律：同一 kind 已有 running 的 run 时，register 抛 RunConflictError
+ * （宿主路由以 409 拒绝新任务，防止重复导出/导入）。
+ */
+import { randomBytes } from 'node:crypto';
+import { zhMsg } from './messages.js';
+/** 单个 run 执行日志的行数上限（防无限增长；截断时保留最新行）。 */
+export const MAX_RUN_LOG_LINES = 500;
+/** 进行中同 kind 已有 run 时注册被拒（宿主路由 → 409）。 */
+export class RunConflictError extends Error {
+    /** 已在进行中的 run id（供客户端定位既有任务）。 */
+    runId;
+    constructor(runId, kind, msg = zhMsg) {
+        super(kind === 'export'
+            ? msg('run.conflict.export', { runId })
+            : kind === 'autosync'
+                ? '自动同步已在进行中'
+                : kind === 'sync-apply'
+                    ? '一键同步已在进行中'
+                    : kind === 'backup-schedule'
+                        ? '定时备份已在进行中'
+                        : kind === 'restore'
+                            ? '快照恢复已在进行中（请等待当前恢复完成）'
+                            : kind === 'recovery'
+                                ? '恢复/回滚已在进行中（请等待当前恢复完成）'
+                                : msg('run.conflict.import', { runId }));
+        this.name = 'RunConflictError';
+        this.runId = runId;
+    }
+}
+/** 完成/失败后的默认保留时长（30 分钟）。 */
+export const DEFAULT_RUN_RETENTION_MS = 30 * 60 * 1000;
+/**
+ * 内存 run 注册表。Node 单线程 + 同步 Map 读写，无并发竞争；
+ * 所有公开读方法返回状态副本，防止外部直接篡改内部状态。
+ */
+export class RunRegistry {
+    runs = new Map();
+    retentionMs;
+    now;
+    msg;
+    constructor(opts = {}) {
+        this.retentionMs = opts.retentionMs ?? DEFAULT_RUN_RETENTION_MS;
+        this.now = opts.now ?? (() => Date.now());
+        this.msg = opts.msg ?? zhMsg;
+    }
+    /** 注册新 run；同 kind 已有 running 时抛 RunConflictError。 */
+    register(kind) {
+        this.prune();
+        for (const run of this.runs.values()) {
+            if (run.kind === kind && run.status === 'running')
+                throw new RunConflictError(run.runId, kind, this.msg);
+        }
+        const now = this.now();
+        const state = {
+            runId: randomBytes(16).toString('hex'),
+            kind,
+            status: 'running',
+            section: null,
+            sectionTotal: null,
+            item: null,
+            itemTotal: null,
+            detail: null,
+            log: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.runs.set(state.runId, state);
+        return { ...state };
+    }
+    /** 更新进度；run 不存在返回 undefined；已完成/失败后的晚到更新被忽略（防御异步回调竞态）。 */
+    update(runId, patch) {
+        const run = this.runs.get(runId);
+        if (run === undefined)
+            return undefined;
+        if (run.status !== 'running')
+            return { ...run };
+        Object.assign(run, patch, { updatedAt: this.now() });
+        return { ...run };
+    }
+    /**
+     * 追加一行执行日志（导入逐计划项操作 / 子进程命令）；run 不存在返回 undefined，
+     * 已完成/失败后的晚到追加被忽略（防御异步回调竞态）。行数封顶 MAX_RUN_LOG_LINES，
+     * 超限时截断保留最新行。
+     *
+     * **不可变写入（性能正确性关键）**：每次 append 生成新数组（push + splice 会原地
+     * mutation —— /progress 轮询返回的 RunState.log 与浏览器侧 store 共享同一引用，
+     * 行数封顶后长度恒定，React memo 按引用/长度比较将无法感知新行，日志面板冻结）。
+     * 调用方（mapRunProgress → ImportLogPanel）据此以「数组引用变化」判断有新输出。
+     */
+    appendLog(runId, line) {
+        const run = this.runs.get(runId);
+        if (run === undefined)
+            return undefined;
+        if (run.status !== 'running')
+            return { ...run };
+        // 不可变追加：保留最新 MAX_RUN_LOG_LINES 行（slice(-(MAX-1)) 在长度不足时取全量）
+        run.log = [...run.log.slice(-(MAX_RUN_LOG_LINES - 1)), line];
+        run.updatedAt = this.now();
+        return { ...run };
+    }
+    /** 读单个 run；超过保留期或不存在返回 undefined。 */
+    get(runId) {
+        this.prune();
+        const run = this.runs.get(runId);
+        return run === undefined ? undefined : { ...run };
+    }
+    /** 列出活跃（running）run（刷新恢复时经 /runs 重订阅用）。 */
+    listActive() {
+        this.prune();
+        return [...this.runs.values()].filter((r) => r.status === 'running').map((r) => ({ ...r }));
+    }
+    /** 标记完成并写入业务结果；run 不存在返回 undefined。 */
+    finish(runId, result) {
+        const run = this.runs.get(runId);
+        if (run === undefined)
+            return undefined;
+        run.status = 'done';
+        run.result = result;
+        run.updatedAt = this.now();
+        return { ...run };
+    }
+    /** 标记失败并写入错误消息；run 不存在返回 undefined。 */
+    fail(runId, error) {
+        const run = this.runs.get(runId);
+        if (run === undefined)
+            return undefined;
+        run.status = 'failed';
+        run.error = error;
+        run.updatedAt = this.now();
+        return { ...run };
+    }
+    /** 惰性清理：超过保留期的 run（含长期 running 的僵死任务）全部移除。 */
+    prune() {
+        const cutoff = this.now() - this.retentionMs;
+        for (const [id, run] of this.runs) {
+            if (run.updatedAt < cutoff)
+                this.runs.delete(id);
+        }
+    }
+}
+//# sourceMappingURL=run-registry.js.map

package/lib/core/startup-barrier.d.ts

@@ -0,0 +1,53 @@
+import type { ReconcileProbeHooks, ReconcileEnv, ReconcileOptions } from './reconcile.ts';
+import type { JournalStore } from './journal.ts';
+export type StartupRecoveryState = {
+    kind: 'NORMAL';
+} | {
+    kind: 'LOCKED_LIVE';
+    operationId?: string;
+} | {
+    kind: 'RECOVERY_REQUIRED';
+    operationId?: string;
+} | {
+    kind: 'NEEDS_ATTENTION';
+    operationId?: string;
+} | {
+    kind: 'UNKNOWN_STATE';
+    reason: string;
+};
+export interface StartupClassifier {
+    classify(): Promise<{
+        state: StartupRecoveryState;
+        safeModeRequired: boolean;
+        recoveryRequired: boolean;
+    }>;
+}
+/** 用 inspectStartup 结果构造分类器。lockState: 'LOCKED'|'STALE_LOCK_DETECTED'|'UNKNOWN_STATE'|'FREE'。 */
+export declare function classifyStartup(opts: {
+    store: JournalStore;
+    hooks: ReconcileProbeHooks;
+    env: ReconcileEnv;
+    options?: ReconcileOptions;
+    lockState: 'LOCKED' | 'STALE_LOCK_DETECTED' | 'UNKNOWN_STATE' | 'FREE';
+}): StartupClassifier;
+export interface StartupSchedulers {
+    start(): void;
+}
+/**
+ * StartupRecoveryController：`await run()` 完成后调度器才可启动。
+ * `startSchedulersIfAllowed()` 只在 NORMAL 启动（幂等）；否则（RECOVERY_REQUIRED/NEEDS_ATTENTION/UNKNOWN/LOCKED_LIVE）
+ * 不启动 destructive schedulers（read-only host 仍活，diagnostics/recovery API 可用）。fail-closed：classify 抛错 → RECOVERY_REQUIRED。
+ */
+export declare class StartupRecoveryController {
+    private state;
+    private settled;
+    private schedulersStarted;
+    private readonly classifier;
+    private readonly schedulers;
+    constructor(classifier: StartupClassifier, schedulers: StartupSchedulers);
+    run(): Promise<StartupRecoveryState>;
+    get stateValue(): StartupRecoveryState;
+    get isSettled(): boolean;
+    /** 仅在 NORMAL 下启动 schedulers（幂等；返回是否已启动）。 */
+    startSchedulersIfAllowed(): boolean;
+}

package/lib/core/startup-barrier.js

@@ -0,0 +1,77 @@
+/**
+ * P1-B：Startup Recovery Barrier。
+ *
+ * Rev 3 §8.3/§26 要求「recovery classification MUST complete BEFORE destructive schedulers may start」。
+ * 本模块提供：
+ *  - `StartupRecoveryState`：启动分类的显式结果（NORMAL / LOCKED_LIVE / RECOVERY_REQUIRED / NEEDS_ATTENTION / UNKNOWN_STATE）。
+ *  - `StartupRecoveryController`：`await run()` 完成分类；`startSchedulersIfAllowed()` 只在 NORMAL 下启动 schedulers（幂等）。
+ *    `failClosed`：任何 inspect 抛错 → 归为 RECOVERY_REQUIRED/NEEDS_ATTENTION，绝不自动 NORMAL，schedulers 不启动。
+ *
+ * 不依赖全局 flag「稍后同步」赌时序——调用方必须 `await run()` 再据 state 决定。read-only 服务可继续（diagnostics/recovery UI）。
+ */
+import { inspectStartup } from './reconcile.js';
+/** 用 inspectStartup 结果构造分类器。lockState: 'LOCKED'|'STALE_LOCK_DETECTED'|'UNKNOWN_STATE'|'FREE'。 */
+export function classifyStartup(opts) {
+    return {
+        async classify() {
+            const insp = await inspectStartup(opts.store, opts.hooks, opts.env, opts.options ?? {}, opts.lockState);
+            let state;
+            if (opts.lockState === 'LOCKED') {
+                // fresh heartbeat：活锁；若仍有 unresolved journal → 视为 live op（LOCKED_LIVE，不作 recovery/接管）
+                state = insp.unresolved.length > 0 ? { kind: 'LOCKED_LIVE', operationId: insp.unresolved[0] } : { kind: 'NORMAL' };
+            }
+            else if (insp.recoveryRequired) {
+                state = { kind: 'RECOVERY_REQUIRED', operationId: insp.unresolved[0] };
+            }
+            else if (insp.unresolved.length > 0 || insp.safeModeRequired) {
+                state = { kind: 'NEEDS_ATTENTION', operationId: insp.unresolved[0] };
+            }
+            else {
+                state = { kind: 'NORMAL' };
+            }
+            return { state, safeModeRequired: insp.safeModeRequired, recoveryRequired: insp.recoveryRequired };
+        },
+    };
+}
+/**
+ * StartupRecoveryController：`await run()` 完成后调度器才可启动。
+ * `startSchedulersIfAllowed()` 只在 NORMAL 启动（幂等）；否则（RECOVERY_REQUIRED/NEEDS_ATTENTION/UNKNOWN/LOCKED_LIVE）
+ * 不启动 destructive schedulers（read-only host 仍活，diagnostics/recovery API 可用）。fail-closed：classify 抛错 → RECOVERY_REQUIRED。
+ */
+export class StartupRecoveryController {
+    state = { kind: 'NEEDS_ATTENTION' };
+    settled = false;
+    schedulersStarted = false;
+    classifier;
+    schedulers;
+    constructor(classifier, schedulers) {
+        this.classifier = classifier;
+        this.schedulers = schedulers;
+    }
+    async run() {
+        try {
+            const r = await this.classifier.classify();
+            this.state = r.state;
+        }
+        catch (err) {
+            // fail closed：inspect 抛错 → 不默认 NORMAL
+            this.state = { kind: 'RECOVERY_REQUIRED', operationId: undefined };
+        }
+        finally {
+            this.settled = true;
+        }
+        return this.state;
+    }
+    get stateValue() { return this.state; }
+    get isSettled() { return this.settled; }
+    /** 仅在 NORMAL 下启动 schedulers（幂等；返回是否已启动）。 */
+    startSchedulersIfAllowed() {
+        if (this.state.kind === 'NORMAL' && !this.schedulersStarted) {
+            this.schedulers.start();
+            this.schedulersStarted = true;
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=startup-barrier.js.map