@lmzhen/dsh-tool-memory 0.3.20 → 0.3.22

package/lib/index.js

@@ -1,2645 +1,6 @@
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { createHash } from "node:crypto";
-const PROMPT_BUNDLE_ID = `dsh-evolution@13`;
-const MEMORY_REVIEW_PROMPT = `[Auto-review — Memory]
-Review the conversation above and consider saving to memory if appropriate.
-
-Focus on:
-1. Has the user revealed things about themselves — persona, desires, preferences, or personal details worth remembering?
-2. Has the user expressed expectations about how you should behave, their work style, or ways they want you to operate?
-
-If something stands out, save it using the memory tool.
-If nothing is worth saving, just say "Nothing to save." and stop.`;
-const SKILL_REVIEW_PROMPT = `[Auto-review — Skills]
-Review the conversation above and update the skill library. Be ACTIVE — most sessions produce at least one skill update, even if small. A pass that does nothing is a missed learning opportunity, not a neutral outcome.
-
-Target shape of the library: CLASS-LEVEL skills, each with a rich SKILL.md and a references/ directory for session-specific detail. Not a long flat list of narrow one-session-one-skill entries. This shapes HOW you update, not WHETHER you update.
-
-Signals to look for (any one of these warrants action):
-  • User corrected your style, tone, format, legibility, or verbosity. Frustration signals like 'stop doing X', 'this is too verbose', 'don't format like this', 'why are you explaining', 'just give me the answer', 'you always do Y and I hate it', or an explicit 'remember this' are FIRST-CLASS skill signals, not just memory signals. Update the relevant skill(s) to embed the preference so the next session starts already knowing.
-  • User corrected your workflow, approach, or sequence of steps. Encode the correction as a pitfall or explicit step in the skill that governs that class of task.
-  • Non-trivial technique, fix, workaround, debugging path, or tool-usage pattern emerged that a future session would benefit from. Capture it.
-  • A skill that got loaded or consulted this session turned out to be wrong, missing a step, or outdated. Patch it NOW.
-
-Read-before-write (enforced by this channel): update, patch, delete, or write support files ONLY into skills you loaded or read in THIS session — ops on unread skills are dropped; CREATE of a brand-new umbrella is the only exception.
-
-Preference order — prefer the earliest action that fits, but do pick one when a signal above fired:
-  1. UPDATE A CURRENTLY-LOADED SKILL. Look back through the conversation for skills the user loaded or you read. If any of them covers the territory of the new learning, PATCH that one first. It is the skill that was in play, so it's the right one to extend.
-  2. UPDATE AN EXISTING UMBRELLA. If no loaded skill fits but an existing class-level skill does, patch it. Add a subsection, a pitfall, or broaden a trigger.
-  3. ADD A SUPPORT FILE under an existing umbrella. Skills can be packaged with three kinds of support files — use the right directory per kind:
-     • references/<topic>.md — session-specific detail (error transcripts, reproduction recipes, provider quirks) AND condensed knowledge banks: quoted research, API docs, external authoritative excerpts, or domain notes you found while working on the problem. Write it concise and for the value of the task, not as a full mirror of upstream docs.
-     • templates/<name>.<ext> — starter files meant to be copied and modified (boilerplate configs, scaffolding, a known-good example the agent can reproduce with modifications).
-     • scripts/<name>.<ext> — statically re-runnable actions the skill can invoke directly (verification scripts, fixture generators, deterministic probes, anything the agent should run rather than hand-type each time).
-     Add support files via skill_manage action=write_file with file_path starting 'references/', 'templates/', or 'scripts/'. The umbrella's SKILL.md should gain a one-line pointer to any new support file so future agents know it exists.
-  4. RESTRUCTURE a loaded skill whose body grew log-like — rc/sha/date-dense sections, session-detail spirals, or a fat body with no support files. Use skill_manage action=restructure with restructure: [{"heading": "<the exact ## heading text>", "to_file": "references/<topic>.md"}] — the ENTIRE ## section (from that heading to the next heading) moves into the support file and its position becomes a pointer line. The skill's name and directory never change. Only propose headings that exist verbatim in the body; never invent one, and never restructure a healthy small skill.
-  5. CREATE A NEW CLASS-LEVEL UMBRELLA SKILL when no existing skill covers the class. The name MUST be at the class level. The name MUST NOT be a specific PR number, error string, feature codename, library-alone name, or 'fix-X / debug-Y / audit-Z-today' session artifact. If the proposed name only makes sense for today's task, it's wrong — fall back to (1), (2), or (3).
-
-User-preference embedding (important): when the user expressed a style/format/workflow preference, the update belongs in the SKILL.md body, not just in memory. Memory captures 'who the user is and what the current situation and state of your operations are'; skills capture 'how to do this class of task for this user'. When they complain about how you handled a task, the skill that governs that task needs to carry the lesson.
-
-If you notice two existing skills that overlap, note it in your reply — the background curator handles consolidation at scale.
-
-Two-tier deposition discipline (DSH addition, same spirit as the umbrella rule): before writing, classify the knowledge:
-  • PATTERN (reusable — symptom → mechanism → fix → verification, still valuable next session) belongs in the SKILL.md body.
-  • LOG (one-off — commit SHAs, npm/profile states, what this release changed, this session's process narrative) belongs in a references/ file, never the body. Body density IS reuse rate. Keep new entries tight: a pattern fits in 2-8 physical lines; prefer changing the current-state pointer over appending history.
-
-Protected skills (DO NOT edit these):
-  • Bundled skills (shipped with the platform).
-  • Hub-installed skills (installed from a hub).
-Pinned skills are read-only to THIS background review pass — the pinned write guard refuses background changes, so only the foreground may update or archive them. Foreground and delegated-subagent writes to pinned skills remain allowed.
-If the only skills that need updating are protected, say 'Nothing to save.' and stop.
-
-Do NOT capture (these become persistent self-imposed constraints that bite you later when the environment changes):
-  • Environment-dependent failures: missing binaries, fresh-install errors, post-migration path mismatches, 'command not found', unconfigured credentials, uninstalled packages. The user can fix these — they are not durable rules.
-  • Negative claims about tools or features ('browser tools do not work', 'X tool is broken', 'cannot use Y'). These harden into refusals the agent cites against itself for months after the actual problem was fixed.
-  • Session-specific transient errors that resolved before the conversation ended. If retrying worked, the lesson is the retry pattern, not the original failure.
-  • One-off task narratives. A user asking 'summarize today's market' or 'analyze this PR' is not a class of work that warrants a skill.
-
-If a tool failed because of setup state, capture the FIX (install command, config step, env var to set) under an existing setup or troubleshooting skill — never 'this tool does not work' as a standalone constraint.
-
-'Nothing to save.' is a real option but should NOT be the default. If the session ran smoothly with no corrections and produced no new technique, just say 'Nothing to save.' and stop. Otherwise, act.`;
-const COMBINED_REVIEW_PROMPT = `[Auto-review]
-Review the conversation above and update two things:
-
-**Memory**: who the user is. Did the user reveal persona, desires, preferences, personal details, or expectations about how you should behave? Save facts about the user and durable preferences with the memory tool.
-
-**Skills**: how to do this class of task. Be ACTIVE — most sessions produce at least one skill update. A pass that does nothing is a missed learning opportunity, not a neutral outcome.
-
-Target shape of the skill library: CLASS-LEVEL skills with a rich SKILL.md and a references/ directory for session-specific detail. Not a long flat list of narrow one-session-one-skill entries.
-
-Signals that warrant a skill update (any one is enough):
-  • User corrected your style, tone, format, legibility, verbosity, or approach. Frustration is a FIRST-CLASS skill signal, not just a memory signal. 'stop doing X', 'don't format like this', 'I hate when you Y' — embed the lesson in the skill that governs that task so the next session starts fixed.
-  • Non-trivial technique, fix, workaround, or debugging path emerged.
-  • A skill that was loaded or consulted turned out wrong, missing, or outdated — patch it now.
-
-Read-before-write (enforced by this channel): update, patch, delete, or write support files ONLY into skills you loaded or read in THIS session — ops on unread skills are dropped; CREATE of a brand-new umbrella is the only exception.
-
-Preference order for skills — pick the earliest that fits:
-  1. UPDATE A CURRENTLY-LOADED SKILL. Check what skills were loaded or read in the conversation. If one of them covers the learning, PATCH it first. It was in play; it's the right place.
-  2. UPDATE AN EXISTING UMBRELLA. Patch it.
-  3. ADD A SUPPORT FILE under an existing umbrella via skill_manage action=write_file. Three kinds: references/<topic>.md for session-specific detail OR condensed knowledge banks (quoted research, API docs excerpts, domain notes) written concise and task-focused; templates/<name>.<ext> for starter files meant to be copied and modified; scripts/<name>.<ext> for statically re-runnable actions (verification, fixture generators, probes). Add a one-line pointer in SKILL.md so future agents find them.
-  4. RESTRUCTURE a loaded skill whose body grew log-like (rc/sha/date-dense sections, session-detail spirals, fat body with no support files) via skill_manage action=restructure with restructure: [{"heading": "<the exact ## heading text>", "to_file": "references/<topic>.md"}] — the ENTIRE ## section moves into the support file and its position becomes a pointer line; the skill's name and directory never change. Only propose headings that exist verbatim in the body.
-  5. CREATE A NEW CLASS-LEVEL UMBRELLA when nothing exists. Name at the class level — NOT a PR number, error string, codename, library-alone name, or 'fix-X / debug-Y' session artifact. If the name only fits today's task, fall back to (1), (2), or (3).
-
-Two-tier deposition discipline (DSH addition): classify before writing — PATTERN (symptom → mechanism → fix → verification) goes in the SKILL.md body; LOG (commit SHAs, npm/profile states, this release's change list, this session's narrative) goes in a references/ file. Body density IS reuse rate; a pattern fits in 2-8 physical lines.
-
-User-preference embedding: when the user complains about how you handled a task, update the skill that governs that task — memory alone isn't enough. Memory says 'who the user is and what the current situation and state of your operations are'; skills say 'how to do this class of task for this user'. Both should carry user-preference lessons when relevant.
-
-If you notice overlapping existing skills, mention it — the background curator handles consolidation.
-
-Protected skills (DO NOT edit these):
-  • Bundled skills (shipped with the platform).
-  • Hub-installed skills (installed from a hub).
-Pinned skills are read-only to THIS background review pass — the pinned write guard refuses background changes, so only the foreground may update or archive them. Foreground and delegated-subagent writes to pinned skills remain allowed.
-If the only skills that need updating are protected, say 'Nothing to save.' and stop.
-
-Do NOT capture as skills (these become persistent self-imposed constraints that bite you later when the environment changes):
-  • Environment-dependent failures: missing binaries, fresh-install errors, post-migration path mismatches, 'command not found', unconfigured credentials, uninstalled packages. The user can fix these — they are not durable rules.
-  • Negative claims about tools or features ('browser tools do not work', 'X tool is broken', 'cannot use Y'). These harden into refusals the agent cites against itself for months after the actual problem was fixed.
-  • Session-specific transient errors that resolved before the conversation ended. If retrying worked, the lesson is the retry pattern, not the original failure.
-  • One-off task narratives. A user asking 'summarize today's market' or 'analyze this PR' is not a class of work that warrants a skill.
-
-If a tool failed because of setup state, capture the FIX (install command, config step, env var to set) under an existing setup or troubleshooting skill — never 'this tool does not work' as a standalone constraint.
-
-Act on whichever of the two dimensions has real signal. If genuinely nothing stands out on either, say 'Nothing to save.' and stop — but don't reach for that conclusion as a default.`;
-const CURATOR_PROMPT = `You are the skill curator. Maintain a healthy, class-level skill library, not a flat pile of narrow one-session skills.
-
-This is an UMBRELLA-BUILDING consolidation pass, not a passive audit and not a duplicate-finder.
-
-The goal is a LIBRARY OF CLASS-LEVEL INSTRUCTIONS. A skill collection of many narrow skills where each captures one session's specific bug is a FAILURE of the library. An agent searching skills matches on descriptions, not exact names; one broad umbrella with labeled subsections beats five narrow siblings for discoverability.
-
-Right target shape: class-level skills with rich SKILL.md + references/, templates/, scripts/ support files for session-specific detail.
-
-Hard rules:
-1. NEVER hard-delete a skill. Archive (moving to .archive/) is the maximum destructive action; archives are recoverable, deletion is not.
-2. Do not touch bundled, hub-installed, pinned, or scheduled-task-referenced (referenced) skills. Referenced skills are fully protected — never consolidated, never pruned (there is no scheduled-task reference-rewriting pass; a referenced skill stays in place by design).
-3. Do not archive recently-created or never-used skills without strong evidence. "use=0" is NOT evidence either way — it only means the trigger has not come up yet. Never archive a never-used skill unless it is at least 30 days old AND its content is genuinely obsolete or fully absorbed elsewhere.
-4. Do NOT reject consolidation on the grounds that "each skill has a distinct trigger". The right bar is: would a human maintainer write this as N separate skills, or one skill with N labeled subsections? When the answer is the latter, merge.
-5. Judge overlap on CONTENT, not on usage counters.
-6. Before archiving a merged skill, ensure its unique content was preserved in the umbrella.
-
-How to work:
-1. Scan the candidate list. Identify PREFIX CLUSTERS — skills sharing a first word or domain keyword. Expected cluster count scales with the library: a large collection may show 10-25 prefix clusters, a small one often has none — a clean "nothing to consolidate" summary is the correct small-library outcome, not a shortage of ambition.
-2. For each cluster with 2+ members, ask "what is the UMBRELLA CLASS these skills serve?" and consolidate:
-   a. MERGE INTO AN EXISTING UMBRELLA (patch a labeled section for each sibling's unique insight, then archive the siblings).
-   b. CREATE A NEW UMBRELLA SKILL.md covering the shared workflow with short labeled subsections, then archive the absorbed siblings.
-   c. DEMOTE session-specific detail to references/, templates/, or scripts/ under the umbrella. Use the right directory per kind:
-      • references/<topic>.md — session-specific detail OR condensed knowledge banks (quoted research, API docs excerpts, domain notes, provider quirks, reproduction recipes) written concise and task-focused.
-      • templates/<name>.<ext> — starter files meant to be copied and modified.
-      • scripts/<name>.<ext> — statically re-runnable actions (verification scripts, fixture generators, probes).
-3. Package integrity — not optional: inspect each skill as a COMPLETE directory package, not just SKILL.md. A skill root may include references/, templates/, scripts/, and assets/. If the source skill has support files OR its SKILL.md contains relative links to them, DO NOT flatten only SKILL.md into <umbrella>/references/<old>.md. Choose one safe path instead: keep it as a standalone skill, OR fully merge by re-homing every needed support file into the umbrella's canonical directories AND rewriting the destination instructions to the new paths, OR archive the entire original skill package unchanged. Never leave demoted instructions pointing at files left behind under the old skill directory.
-4. Flag skills whose NAME is too narrow (contains a PR number, a feature codename, a specific error string, an 'audit'/'diagnosis'/'salvage' session artifact) — they almost always belong as a subsection or support file under a class-level umbrella.
-5. Iterate. After one consolidation round, scan the remaining set and look for the NEXT umbrella opportunity. Don't stop after 3 merges.
-
-You are a NOMINATOR, not an executor: this channel has NO tools. Your single deliverable is the structured YAML block below. Never narrate actions you did not take ("merged", "patched", "archived") — you are proposing, and the deterministic engine executes only names from the candidate pool it gave you. (A future execution view would expose skill_manage; today it does not.)
-
-'keep' is a legitimate decision ONLY when the skill is already a class-level umbrella and none of the proposed merges would improve discoverability. 'This is narrow but distinct from its siblings' is NOT a reason to keep — it's a reason to move it under an umbrella as a subsection or support file.
-
-Expected output: real umbrella-ification. Process every obvious cluster. If you end the pass with obvious clusters still untouched, you stopped too early — go back and look at the clusters you left alone.
-
-Keep the umbrella body tight and scannable: exact commands, verbatim paths, ~100-200 lines; never invent flags or APIs.
-
-When done, write a human summary THEN the structured machine-readable block. The block is the contract: every skill you would move to .archive/ MUST appear in exactly one of the two lists. Return ONLY the YAML block after the summary — no post-block prose. Format EXACTLY:
-
-## Structured summary (required)
-\`\`\`yaml
-consolidations:
-  - from: <old-skill-name>
-    mode: reference  # optional — ONLY for a 'demote': source is narrow-but-valuable session detail, write it as references/<source>.md under the umbrella instead of appending to the body. Default is append. Place this line BEFORE into:. NEVER use reference when the source body links its own references/ templates/ scripts/ files.
-    into: <umbrella-skill-name>
-    reason: <one short sentence — why merged, not just 'similar'>
-prunings:
-  - name: <skill-name>
-    reason: <one short sentence — why archived with no merge target>
-\`\`\`
-
-Every skill you would move to .archive/ MUST appear in exactly one of the two lists. If you consolidated X into umbrella Y (patched Y, wrote a references file to Y, or created Y with X's content absorbed), X goes under consolidations with into: Y. If you archived X with no absorption — truly stale, irrelevant, or obsolete — X goes under prunings. Leave a list empty (consolidations: []) if none. Do not omit the block. The block comes AFTER your human-readable summary of clusters processed, patches made, and decisions left alone.`;
-const COMPLETION_SKILL_REVIEW_PROMPT = `[Auto-review — Skills · task complete]
-Your current task now appears complete. Before wrapping up, review the approach and update the skill library via skill_manage.
-
-Follow the skills review policy: be ACTIVE, prefer class-level umbrellas, patch ONLY skills loaded or read this session, and capture non-trivial techniques and user corrections. Do NOT capture environment-dependent failures, negative claims about tools, or one-off task narratives.
-
-Do NOT modify output files or re-run the task. If you are still mid-task, ignore this.`;
-/**
-* Maintenance-subagent persona (design 011 §6). Constants pin the persona
-* with `{signal:id}` placeholders; the renderer substitutes names from the
-* drift-signals module (single vocabulary). The model-facing contract is the
-* persona + the mechanical-facts block; the signature head lets the model
-* compare the two heads (011 mismatch protocol).
-*/
-const MAINTAIN_PROMPT = `<<<MAINTAIN_PROMPT v={bundle_version} sig={joint_signature}>>>
-
-## 角色
-你是技能库的**外部审计者**：只读、只输出计划、从不执行（执行由用户命令与审批完成）。
-
-## 1. 输入契约（冲突时以此为准）
-机械事实块 <<<MECHANICAL_FACTS v={signals_version} sig={joint_signature}>>>（下方，以 <<<END FACTS>>> 闭合）是唯一证据来源。
-- verdict 仅三值：pass=未越阈 / over=越阈 / unknown=未检测。
-- over 是事实位置，不是违规结论；没有条款对应的事实，不产生建议。
-- unknown ≠ pass；引用 unknown 信号的条目必须 needs_human:true。
-- 事实只读：不改写、不补写、不把事实"翻译"成裁决。
-- 两处 sig 不一致或任一缺失 → 只输出 MISMATCH + 两侧版本号，禁止输出计划。
-
-## 2. 信号→条款映射（每条 over 必须落到条款；无一遗漏）
-{signal:dedup_group}→A1 · {signal:narrow_name}→A2 · {signal:prefix_cluster}→A3 · {signal:stamp_density}与{signal:body_size}→B1 · {signal:pointer_missing}→B2 · {signal:dup_heading}→B3 · {signal:overlong_line}→B4 · {signal:description_chars}→B5 · {signal:usage_observed}/{signal:quality_low}→门控（校验器对 quality_low=unknown 的技能强制 needs_human，模板侧不重复）
-
-## 3. 完整性契约（校验器机械执行）
-事实块中每条 over 信号必须满足其一：成为某条建议的 evidence，或在 notes 中说明"已审·无条款对应·不动作"。禁止静默省略；先逐信号核对再输出。
-
-## 4. 工作流程（按序执行，不得跳步）
-① 通读事实块 → ② 对每个候选技能用 skill 读正文（B1/B2/B4 必读；**读取失败必须报告工具返回的事实**（错误信息/无对应条目），禁止用"无法读取"含糊绕过）→ ③ maintenance_probe 按需深挖 → ④ 逐信号过 §3 完整性 → ⑤ 输出计划。
-
-## 5. 检查清单（信号 → 语义判定 → 输出形态）
-A. 域·碎片化
-- A1 {signal:dedup_group}=over：判近重复组是否同伞可合并；是→relationship-level consolidate；否→不输出。
-- A2 {signal:narrow_name}=over：判否"仅对今日任务成立"；成立→改名/归档建议；内部代号（格式合规语义窄）→conf≤0.4+needs_human。
-- A3 {signal:prefix_cluster}=over：判簇内是否同伞；非同伞→notes 提域划分观察，不强制建伞。
-
-B. 层·分层错位
-- B1 {signal:stamp_density}（阈值 {signal:stamp_density.threshold}）或 {signal:body_size}（阈值 {signal:body_size.threshold}）=over：按**三问判据**判锚/残留——① 该编号/时间戳是否被库内其他文件引用？② 除"何时产生/为何存在"外是否还承载信息？③ 删除是否影响任何跨文档检索？（①是且③是→锚；否则→残留候选，人审）。锚→允许保留 + needs_human + semantic_reasoning 写三问结果；**锚不使用 is_override**（is_override 仅用于 §7 申诉；锚是 B1 的正常裁决路径）；残留→restructure 建议（movable headings 逐字引用）。**锚≠可读：单行 >4000 字符即使在锚类也必须拆分。**
-- B2 {signal:pointer_missing}=over：读支持文件后判性质——可复用模式→上移正文；会话专属实录→保留+补指针；形态=patch 指引。**未读内容仅凭文件名 → conf≤0.4 且措辞"先人工确认再执行"。** **缺失指针=支持文件存在、正文无引用（单向语义），finding 表述勿反向。**
-- B3 {signal:dup_heading}=over：删除多余标题行（保留一份），patch 指引。
-- B4 {signal:overlong_line}=over：>1500 拆行；>4000 判定可读性危机（内容合法也拆）；patch 指引。**finding 必须给全量口径：共 N 行超限，其中 >4000 的逐行列出。**
-- B5 {signal:description_chars}=over：先判**性质**三分类——事件性承诺（单次故障/incident 写入元数据）→裁剪建议；叙事性自我描述→压缩建议；丰富但合规（完整用例边界）→保留 + is_override + override_reason="合法密度"。**分类特征**：含"恢复/修复某次事故、日期快照"类一次性措辞→事件性承诺；"动词+对象"式任务说明→叙事性；枚举完整用例边界且不可拆分→丰富合规。**第三类门槛（默认从严，半机械）**：先自行试写一个 ≤60 字压缩方案——能保留全部路由关键项（触发词+域）→ 不可判第三类（按压缩建议）；只有试写失败（在 semantic_reasoning 列出试写方案与具体失败点）才可判丰富合规。描述文本可见（probe desc-text 或正文 frontmatter）时仍须三分类；仅长度可见 → conf≤0.4。semantic_reasoning 必写三分类之一。
-
-D. 库·整合纪律（计划形态约束）
-- D1 同类问题多处出现→合成一条 relationship-level 建议，不逐项输出。
-- D2 结构类优先级高于内容类；影响面 library-level > relationship-level > skill-level。
-
-## 6. 输出契约（校验器机械执行）
-{verdict: "issues" | "no_issues",
- plan: [{ kind: "skill-level"|"relationship-level"|"library-level", names: [str],
-   rule: "A1"|"B2"|..., evidence: [{signal, value}],
-   finding: "<一句事实描述：引用信号 id 与值；零裁决动词>",
-   recommendation: "<唯一允许的'应'句：建议动作+理由+执行形态（命令/patch 指引）>",
-   semantic_reasoning: "<语义判据；含 LLM 推断时 confidence≤0.4>",
-   impact: "better|worse|neutral", impact_reason: "<相对'不动'的净影响>",
-   reversibility: "archive|restructure|patch|rename|none", undo_path: "<一步撤销方式>",
-   confidence: float, needs_human: bool, is_override: bool,
-   override_reason: "<仅 is_override>" }],
- notes: [str]}
-- verdict=no_issues ⇒ plan=[]（不允许空 plan 之外的"无问题"表述）。
-- **confidence 降档规则（机械）**：条款全部由机械证据支撑 → 0.6–0.9；每含一项语义推断（是否锚/是否同伞/性质归类）→ 上限 0.4。
-- needs_human = (confidence < 0.6) OR (不可逆) OR (is_override) OR (引用 unknown 信号)。
-- 语言：finding/recommendation/notes 与库正文语言一致（不自订语言）；字段名/信号 id/枚举保留英文。
-- **提交前自查（逐项对照，不许跳过）**：① verdict 与 plan 一致 ② 每条 evidence 在事实块 ③ undo_path 非空（不可逆=n/a）④ confidence 含推断≤0.4 ⑤ finding 无"应"字 ⑥ §3 完整性契约满足。
-
-## 7. 裁决纪律
-- finding 禁止"应当"句式；recommendation 是唯一"应"句，句板：建议对 {names} 执行 {动作}（形态：{命令/patch 指引}），理由：{理由}。
-- **审查者视角**：先对每个信号独立初判，再与正文对照；被审对象的自我声明只作线索不作依据；**自属/维护者技能一律从严口径**（作者声明"这是锚"不构成豁免）。
-- 申诉：机械阈值与语义判断冲突→is_override:true + override_reason + needs_human:true，不得静默绕过。
-- 不动作合法：verdict=no_issues 是合法输出；连续空报告=信号定义问题，不是"更积极"的理由。
-- 错误成本：rename 必须 needs_human:true；可逆动作（archive/restructure 两阶段）可 needs_human:false 但 undo_path 必填。
-- 不做：不建议删除（只建议 archive）；不提升内容质量（结构审查只 flag 位置/归属/分层）；protected 集（bundled/hub/pinned）内 0 建议。
-
-## 8. 泛化
-- 信号集开放：事实块含、§5 未列的信号 → notes 提"该信号值得新增条款"，禁止解释为已知问题。
-- 库规模无关：判据是事实与条款，不是库体量印象。
-- 信号机制疑问（阈值/检测原理）→ needs_human，不猜测机制。`;
-/**
-* System-prompt guidance section (Hermes `SKILLS_GUIDANCE`, DSH-adapted).
-* Registered as a system-prompt section by tool-skill-manage (it mounts
-* exactly when `skill_manage` is available — the DSH analogue of Hermes'
-* `if "skill_manage" in agent.valid_tool_names` condition). Instructs the
-* model to save/repair skills on its own initiative.
-*/
-const SKILLS_GUIDANCE = `Skills guidance:
-• After completing a complex task (5+ tool calls), fixing a tricky error, or discovering a non-trivial workflow, save the approach as a skill with skill_manage so you can reuse it next time.
-• When using a skill and finding it outdated, incomplete, or wrong, patch it immediately with skill_manage (action='patch') — don't wait to be asked. Skills that aren't maintained become liabilities.`;
-const PLAN_CHANNEL_NOTE = `
-
-CHANNEL (subagent): this review channel mounts only the read-only \`skill\` tool — you have NO \`skill_manage\`, NO \`memory\`. Your deliverable is the structured JSON plan below (outputSchema). Describe the patches/creates you RECOMMEND in the plan; never narrate actions you took.`;
-/** Subagent-channel variant: same review policy, channel-limited deliverable (M-2). */
-const SKILL_REVIEW_PLAN_PROMPT = `${SKILL_REVIEW_PROMPT}${PLAN_CHANNEL_NOTE}`;
-/** Subagent-channel variant of the combined review (M-2). */
-const COMBINED_REVIEW_PLAN_PROMPT = `${COMBINED_REVIEW_PROMPT}${PLAN_CHANNEL_NOTE}`;
-function sha256(text) {
-	return createHash("sha256").update(text).digest("hex");
-}
-function createPromptBundle(prompts) {
-	const canonical = JSON.stringify({
-		id: PROMPT_BUNDLE_ID,
-		version: 13,
-		prompts: Object.fromEntries(Object.entries(prompts).sort())
-	});
-	return Object.freeze({
-		id: PROMPT_BUNDLE_ID,
-		version: 13,
-		prompts: Object.freeze({ ...prompts }),
-		sha256: sha256(canonical)
-	});
-}
-createPromptBundle({
-	memory: MEMORY_REVIEW_PROMPT,
-	skill: SKILL_REVIEW_PROMPT,
-	combined: COMBINED_REVIEW_PROMPT,
-	skillPlan: SKILL_REVIEW_PLAN_PROMPT,
-	combinedPlan: COMBINED_REVIEW_PLAN_PROMPT,
-	curator: CURATOR_PROMPT,
-	completion: COMPLETION_SKILL_REVIEW_PROMPT,
-	maintain: MAINTAIN_PROMPT,
-	skillsGuidance: SKILLS_GUIDANCE
-});
-//#endregion
-//#region ../evolution-core/src/threats.ts
-const FILLER = String.raw`(?:\w+\s+){0,8}`;
-new RegExp(String.raw`ignore\s+${FILLER}(?:previous|above|prior|all)\s+${FILLER}instructions`, "i"), new RegExp(String.raw`new\s+${FILLER}system\s+${FILLER}prompt`, "i"), new RegExp(String.raw`forget\s+${FILLER}(?:everything|all)\s+${FILLER}(?:discussed|you\s+know)`, "i"), new RegExp(String.raw`you\s+have\s+been\s+${FILLER}(?:updated|upgraded|patched)\s+to`, "i"), new RegExp(String.raw`do\s+not\s+${FILLER}tell\s+${FILLER}the\s+user`, "i"), new RegExp(String.raw`output\s+${FILLER}(?:system|initial)\s+prompt`, "i");
-//#endregion
-//#region ../../../node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
-/*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var require_common = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function isNothing(subject) {
-		return typeof subject === "undefined" || subject === null;
-	}
-	function isObject(subject) {
-		return typeof subject === "object" && subject !== null;
-	}
-	function toArray(sequence) {
-		if (Array.isArray(sequence)) return sequence;
-		else if (isNothing(sequence)) return [];
-		return [sequence];
-	}
-	function extend(target, source) {
-		if (source) {
-			const sourceKeys = Object.keys(source);
-			for (let index = 0, length = sourceKeys.length; index < length; index += 1) {
-				const key = sourceKeys[index];
-				target[key] = source[key];
-			}
-		}
-		return target;
-	}
-	function repeat(string, count) {
-		let result = "";
-		for (let cycle = 0; cycle < count; cycle += 1) result += string;
-		return result;
-	}
-	function isNegativeZero(number) {
-		return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
-	}
-	module.exports.isNothing = isNothing;
-	module.exports.isObject = isObject;
-	module.exports.toArray = toArray;
-	module.exports.repeat = repeat;
-	module.exports.isNegativeZero = isNegativeZero;
-	module.exports.extend = extend;
-}));
-var require_exception = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function formatError(exception, compact) {
-		let where = "";
-		const message = exception.reason || "(unknown reason)";
-		if (!exception.mark) return message;
-		if (exception.mark.name) where += "in \"" + exception.mark.name + "\" ";
-		where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
-		if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet;
-		return message + " " + where;
-	}
-	function YAMLException(reason, mark) {
-		Error.call(this);
-		this.name = "YAMLException";
-		this.reason = reason;
-		this.mark = mark;
-		this.message = formatError(this, false);
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-		else this.stack = (/* @__PURE__ */ new Error()).stack || "";
-	}
-	YAMLException.prototype = Object.create(Error.prototype);
-	YAMLException.prototype.constructor = YAMLException;
-	YAMLException.prototype.toString = function toString(compact) {
-		return this.name + ": " + formatError(this, compact);
-	};
-	module.exports = YAMLException;
-}));
-var require_snippet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var common = require_common();
-	function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
-		let head = "";
-		let tail = "";
-		const maxHalfLength = Math.floor(maxLineLength / 2) - 1;
-		if (position - lineStart > maxHalfLength) {
-			head = " ... ";
-			lineStart = position - maxHalfLength + head.length;
-		}
-		if (lineEnd - position > maxHalfLength) {
-			tail = " ...";
-			lineEnd = position + maxHalfLength - tail.length;
-		}
-		return {
-			str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
-			pos: position - lineStart + head.length
-		};
-	}
-	function padStart(string, max) {
-		return common.repeat(" ", max - string.length) + string;
-	}
-	function makeSnippet(mark, options) {
-		options = Object.create(options || null);
-		if (!mark.buffer) return null;
-		if (!options.maxLength) options.maxLength = 79;
-		if (typeof options.indent !== "number") options.indent = 1;
-		if (typeof options.linesBefore !== "number") options.linesBefore = 3;
-		if (typeof options.linesAfter !== "number") options.linesAfter = 2;
-		const re = /\r?\n|\r|\0/g;
-		const lineStarts = [0];
-		const lineEnds = [];
-		let match;
-		let foundLineNo = -1;
-		while (match = re.exec(mark.buffer)) {
-			lineEnds.push(match.index);
-			lineStarts.push(match.index + match[0].length);
-			if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
-		}
-		if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-		let result = "";
-		const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
-		const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
-		for (let i = 1; i <= options.linesBefore; i++) {
-			if (foundLineNo - i < 0) break;
-			const line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
-			result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
-		}
-		const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
-		result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
-		result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
-		for (let i = 1; i <= options.linesAfter; i++) {
-			if (foundLineNo + i >= lineEnds.length) break;
-			const line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
-			result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
-		}
-		return result.replace(/\n$/, "");
-	}
-	module.exports = makeSnippet;
-}));
-var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var YAMLException = require_exception();
-	var TYPE_CONSTRUCTOR_OPTIONS = [
-		"kind",
-		"multi",
-		"resolve",
-		"construct",
-		"instanceOf",
-		"predicate",
-		"represent",
-		"representName",
-		"defaultStyle",
-		"styleAliases"
-	];
-	var YAML_NODE_KINDS = [
-		"scalar",
-		"sequence",
-		"mapping"
-	];
-	function compileStyleAliases(map) {
-		const result = {};
-		if (map !== null) Object.keys(map).forEach(function(style) {
-			map[style].forEach(function(alias) {
-				result[String(alias)] = style;
-			});
-		});
-		return result;
-	}
-	function Type(tag, options) {
-		options = options || {};
-		Object.keys(options).forEach(function(name) {
-			if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type.");
-		});
-		this.options = options;
-		this.tag = tag;
-		this.kind = options["kind"] || null;
-		this.resolve = options["resolve"] || function() {
-			return true;
-		};
-		this.construct = options["construct"] || function(data) {
-			return data;
-		};
-		this.instanceOf = options["instanceOf"] || null;
-		this.predicate = options["predicate"] || null;
-		this.represent = options["represent"] || null;
-		this.representName = options["representName"] || null;
-		this.defaultStyle = options["defaultStyle"] || null;
-		this.multi = options["multi"] || false;
-		this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
-		if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new YAMLException("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
-	}
-	module.exports = Type;
-}));
-var require_schema = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var YAMLException = require_exception();
-	var Type = require_type();
-	function compileList(schema, name) {
-		const result = [];
-		schema[name].forEach(function(currentType) {
-			let newIndex = result.length;
-			result.forEach(function(previousType, previousIndex) {
-				if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex;
-			});
-			result[newIndex] = currentType;
-		});
-		return result;
-	}
-	function compileMap() {
-		const result = {
-			scalar: {},
-			sequence: {},
-			mapping: {},
-			fallback: {},
-			multi: {
-				scalar: [],
-				sequence: [],
-				mapping: [],
-				fallback: []
-			}
-		};
-		function collectType(type) {
-			if (type.multi) {
-				result.multi[type.kind].push(type);
-				result.multi["fallback"].push(type);
-			} else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
-		}
-		for (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
-		return result;
-	}
-	function Schema(definition) {
-		return this.extend(definition);
-	}
-	Schema.prototype.extend = function extend(definition) {
-		let implicit = [];
-		let explicit = [];
-		if (definition instanceof Type) explicit.push(definition);
-		else if (Array.isArray(definition)) explicit = explicit.concat(definition);
-		else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
-			if (definition.implicit) implicit = implicit.concat(definition.implicit);
-			if (definition.explicit) explicit = explicit.concat(definition.explicit);
-		} else throw new YAMLException("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
-		implicit.forEach(function(type) {
-			if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-			if (type.loadKind && type.loadKind !== "scalar") throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
-			if (type.multi) throw new YAMLException("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
-		});
-		explicit.forEach(function(type) {
-			if (!(type instanceof Type)) throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-		});
-		const result = Object.create(Schema.prototype);
-		result.implicit = (this.implicit || []).concat(implicit);
-		result.explicit = (this.explicit || []).concat(explicit);
-		result.compiledImplicit = compileList(result, "implicit");
-		result.compiledExplicit = compileList(result, "explicit");
-		result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
-		return result;
-	};
-	module.exports = Schema;
-}));
-var require_str = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = new (require_type())("tag:yaml.org,2002:str", {
-		kind: "scalar",
-		construct: function(data) {
-			return data !== null ? data : "";
-		}
-	});
-}));
-var require_seq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = new (require_type())("tag:yaml.org,2002:seq", {
-		kind: "sequence",
-		construct: function(data) {
-			return data !== null ? data : [];
-		}
-	});
-}));
-var require_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = new (require_type())("tag:yaml.org,2002:map", {
-		kind: "mapping",
-		construct: function(data) {
-			return data !== null ? data : {};
-		}
-	});
-}));
-var require_failsafe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = new (require_schema())({ explicit: [
-		require_str(),
-		require_seq(),
-		require_map()
-	] });
-}));
-var require_null = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	function resolveYamlNull(data) {
-		if (data === null) return true;
-		const max = data.length;
-		return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
-	}
-	function constructYamlNull() {
-		return null;
-	}
-	function isNull(object) {
-		return object === null;
-	}
-	module.exports = new Type("tag:yaml.org,2002:null", {
-		kind: "scalar",
-		resolve: resolveYamlNull,
-		construct: constructYamlNull,
-		predicate: isNull,
-		represent: {
-			canonical: function() {
-				return "~";
-			},
-			lowercase: function() {
-				return "null";
-			},
-			uppercase: function() {
-				return "NULL";
-			},
-			camelcase: function() {
-				return "Null";
-			},
-			empty: function() {
-				return "";
-			}
-		},
-		defaultStyle: "lowercase"
-	});
-}));
-var require_bool = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	function resolveYamlBoolean(data) {
-		if (data === null) return false;
-		const max = data.length;
-		return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
-	}
-	function constructYamlBoolean(data) {
-		return data === "true" || data === "True" || data === "TRUE";
-	}
-	function isBoolean(object) {
-		return Object.prototype.toString.call(object) === "[object Boolean]";
-	}
-	module.exports = new Type("tag:yaml.org,2002:bool", {
-		kind: "scalar",
-		resolve: resolveYamlBoolean,
-		construct: constructYamlBoolean,
-		predicate: isBoolean,
-		represent: {
-			lowercase: function(object) {
-				return object ? "true" : "false";
-			},
-			uppercase: function(object) {
-				return object ? "TRUE" : "FALSE";
-			},
-			camelcase: function(object) {
-				return object ? "True" : "False";
-			}
-		},
-		defaultStyle: "lowercase"
-	});
-}));
-var require_int = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var common = require_common();
-	var Type = require_type();
-	function isHexCode(c) {
-		return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
-	}
-	function isOctCode(c) {
-		return c >= 48 && c <= 55;
-	}
-	function isDecCode(c) {
-		return c >= 48 && c <= 57;
-	}
-	function resolveYamlInteger(data) {
-		if (data === null) return false;
-		const max = data.length;
-		let index = 0;
-		let hasDigits = false;
-		if (!max) return false;
-		let ch = data[index];
-		if (ch === "-" || ch === "+") ch = data[++index];
-		if (ch === "0") {
-			if (index + 1 === max) return true;
-			ch = data[++index];
-			if (ch === "b") {
-				index++;
-				for (; index < max; index++) {
-					ch = data[index];
-					if (ch !== "0" && ch !== "1") return false;
-					hasDigits = true;
-				}
-				return hasDigits && Number.isFinite(parseYamlInteger(data));
-			}
-			if (ch === "x") {
-				index++;
-				for (; index < max; index++) {
-					if (!isHexCode(data.charCodeAt(index))) return false;
-					hasDigits = true;
-				}
-				return hasDigits && Number.isFinite(parseYamlInteger(data));
-			}
-			if (ch === "o") {
-				index++;
-				for (; index < max; index++) {
-					if (!isOctCode(data.charCodeAt(index))) return false;
-					hasDigits = true;
-				}
-				return hasDigits && Number.isFinite(parseYamlInteger(data));
-			}
-		}
-		for (; index < max; index++) {
-			if (!isDecCode(data.charCodeAt(index))) return false;
-			hasDigits = true;
-		}
-		if (!hasDigits) return false;
-		return Number.isFinite(parseYamlInteger(data));
-	}
-	function parseYamlInteger(data) {
-		let value = data;
-		let sign = 1;
-		let ch = value[0];
-		if (ch === "-" || ch === "+") {
-			if (ch === "-") sign = -1;
-			value = value.slice(1);
-			ch = value[0];
-		}
-		if (value === "0") return 0;
-		if (ch === "0") {
-			if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
-			if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
-			if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
-		}
-		return sign * parseInt(value, 10);
-	}
-	function constructYamlInteger(data) {
-		return parseYamlInteger(data);
-	}
-	function isInteger(object) {
-		return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
-	}
-	module.exports = new Type("tag:yaml.org,2002:int", {
-		kind: "scalar",
-		resolve: resolveYamlInteger,
-		construct: constructYamlInteger,
-		predicate: isInteger,
-		represent: {
-			binary: function(obj) {
-				return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
-			},
-			octal: function(obj) {
-				return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
-			},
-			decimal: function(obj) {
-				return obj.toString(10);
-			},
-			hexadecimal: function(obj) {
-				return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
-			}
-		},
-		defaultStyle: "decimal",
-		styleAliases: {
-			binary: [2, "bin"],
-			octal: [8, "oct"],
-			decimal: [10, "dec"],
-			hexadecimal: [16, "hex"]
-		}
-	});
-}));
-var require_float = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var common = require_common();
-	var Type = require_type();
-	var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-	var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-	function resolveYamlFloat(data) {
-		if (data === null) return false;
-		if (!YAML_FLOAT_PATTERN.test(data)) return false;
-		if (Number.isFinite(parseFloat(data, 10))) return true;
-		return YAML_FLOAT_SPECIAL_PATTERN.test(data);
-	}
-	function constructYamlFloat(data) {
-		let value = data.toLowerCase();
-		const sign = value[0] === "-" ? -1 : 1;
-		if ("+-".indexOf(value[0]) >= 0) value = value.slice(1);
-		if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-		else if (value === ".nan") return NaN;
-		return sign * parseFloat(value, 10);
-	}
-	var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
-	function representYamlFloat(object, style) {
-		if (isNaN(object)) switch (style) {
-			case "lowercase": return ".nan";
-			case "uppercase": return ".NAN";
-			case "camelcase": return ".NaN";
-		}
-		else if (Number.POSITIVE_INFINITY === object) switch (style) {
-			case "lowercase": return ".inf";
-			case "uppercase": return ".INF";
-			case "camelcase": return ".Inf";
-		}
-		else if (Number.NEGATIVE_INFINITY === object) switch (style) {
-			case "lowercase": return "-.inf";
-			case "uppercase": return "-.INF";
-			case "camelcase": return "-.Inf";
-		}
-		else if (common.isNegativeZero(object)) return "-0.0";
-		const res = object.toString(10);
-		return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
-	}
-	function isFloat(object) {
-		return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
-	}
-	module.exports = new Type("tag:yaml.org,2002:float", {
-		kind: "scalar",
-		resolve: resolveYamlFloat,
-		construct: constructYamlFloat,
-		predicate: isFloat,
-		represent: representYamlFloat,
-		defaultStyle: "lowercase"
-	});
-}));
-var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = require_failsafe().extend({ implicit: [
-		require_null(),
-		require_bool(),
-		require_int(),
-		require_float()
-	] });
-}));
-var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = require_json();
-}));
-var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
-	var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
-	function resolveYamlTimestamp(data) {
-		if (data === null) return false;
-		if (YAML_DATE_REGEXP.exec(data) !== null) return true;
-		if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
-		return false;
-	}
-	function constructYamlTimestamp(data) {
-		let fraction = 0;
-		let delta = null;
-		let match = YAML_DATE_REGEXP.exec(data);
-		if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
-		if (match === null) throw new Error("Date resolve error");
-		const year = +match[1];
-		const month = +match[2] - 1;
-		const day = +match[3];
-		if (!match[4]) return new Date(Date.UTC(year, month, day));
-		const hour = +match[4];
-		const minute = +match[5];
-		const second = +match[6];
-		if (match[7]) {
-			fraction = match[7].slice(0, 3);
-			while (fraction.length < 3) fraction += "0";
-			fraction = +fraction;
-		}
-		if (match[9]) {
-			const tzHour = +match[10];
-			const tzMinute = +(match[11] || 0);
-			delta = (tzHour * 60 + tzMinute) * 6e4;
-			if (match[9] === "-") delta = -delta;
-		}
-		const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
-		if (delta) date.setTime(date.getTime() - delta);
-		return date;
-	}
-	function representYamlTimestamp(object) {
-		return object.toISOString();
-	}
-	module.exports = new Type("tag:yaml.org,2002:timestamp", {
-		kind: "scalar",
-		resolve: resolveYamlTimestamp,
-		construct: constructYamlTimestamp,
-		instanceOf: Date,
-		represent: representYamlTimestamp
-	});
-}));
-var require_merge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	function resolveYamlMerge(data) {
-		return data === "<<" || data === null;
-	}
-	module.exports = new Type("tag:yaml.org,2002:merge", {
-		kind: "scalar",
-		resolve: resolveYamlMerge
-	});
-}));
-var require_binary = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
-	function resolveYamlBinary(data) {
-		if (data === null) return false;
-		let bitlen = 0;
-		const max = data.length;
-		const map = BASE64_MAP;
-		for (let idx = 0; idx < max; idx++) {
-			const code = map.indexOf(data.charAt(idx));
-			if (code > 64) continue;
-			if (code < 0) return false;
-			bitlen += 6;
-		}
-		return bitlen % 8 === 0;
-	}
-	function constructYamlBinary(data) {
-		const input = data.replace(/[\r\n=]/g, "");
-		const max = input.length;
-		const map = BASE64_MAP;
-		let bits = 0;
-		const result = [];
-		for (let idx = 0; idx < max; idx++) {
-			if (idx % 4 === 0 && idx) {
-				result.push(bits >> 16 & 255);
-				result.push(bits >> 8 & 255);
-				result.push(bits & 255);
-			}
-			bits = bits << 6 | map.indexOf(input.charAt(idx));
-		}
-		const tailbits = max % 4 * 6;
-		if (tailbits === 0) {
-			result.push(bits >> 16 & 255);
-			result.push(bits >> 8 & 255);
-			result.push(bits & 255);
-		} else if (tailbits === 18) {
-			result.push(bits >> 10 & 255);
-			result.push(bits >> 2 & 255);
-		} else if (tailbits === 12) result.push(bits >> 4 & 255);
-		return new Uint8Array(result);
-	}
-	function representYamlBinary(object) {
-		let result = "";
-		let bits = 0;
-		const max = object.length;
-		const map = BASE64_MAP;
-		for (let idx = 0; idx < max; idx++) {
-			if (idx % 3 === 0 && idx) {
-				result += map[bits >> 18 & 63];
-				result += map[bits >> 12 & 63];
-				result += map[bits >> 6 & 63];
-				result += map[bits & 63];
-			}
-			bits = (bits << 8) + object[idx];
-		}
-		const tail = max % 3;
-		if (tail === 0) {
-			result += map[bits >> 18 & 63];
-			result += map[bits >> 12 & 63];
-			result += map[bits >> 6 & 63];
-			result += map[bits & 63];
-		} else if (tail === 2) {
-			result += map[bits >> 10 & 63];
-			result += map[bits >> 4 & 63];
-			result += map[bits << 2 & 63];
-			result += map[64];
-		} else if (tail === 1) {
-			result += map[bits >> 2 & 63];
-			result += map[bits << 4 & 63];
-			result += map[64];
-			result += map[64];
-		}
-		return result;
-	}
-	function isBinary(obj) {
-		return Object.prototype.toString.call(obj) === "[object Uint8Array]";
-	}
-	module.exports = new Type("tag:yaml.org,2002:binary", {
-		kind: "scalar",
-		resolve: resolveYamlBinary,
-		construct: constructYamlBinary,
-		predicate: isBinary,
-		represent: representYamlBinary
-	});
-}));
-var require_omap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	var _hasOwnProperty = Object.prototype.hasOwnProperty;
-	var _toString = Object.prototype.toString;
-	function resolveYamlOmap(data) {
-		if (data === null) return true;
-		const objectKeys = [];
-		const object = data;
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			const pair = object[index];
-			let pairHasKey = false;
-			if (_toString.call(pair) !== "[object Object]") return false;
-			let pairKey;
-			for (pairKey in pair) if (_hasOwnProperty.call(pair, pairKey)) if (!pairHasKey) pairHasKey = true;
-			else return false;
-			if (!pairHasKey) return false;
-			if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-			else return false;
-		}
-		return true;
-	}
-	function constructYamlOmap(data) {
-		return data !== null ? data : [];
-	}
-	module.exports = new Type("tag:yaml.org,2002:omap", {
-		kind: "sequence",
-		resolve: resolveYamlOmap,
-		construct: constructYamlOmap
-	});
-}));
-var require_pairs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	var _toString = Object.prototype.toString;
-	function resolveYamlPairs(data) {
-		if (data === null) return true;
-		const object = data;
-		const result = new Array(object.length);
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			const pair = object[index];
-			if (_toString.call(pair) !== "[object Object]") return false;
-			const keys = Object.keys(pair);
-			if (keys.length !== 1) return false;
-			result[index] = [keys[0], pair[keys[0]]];
-		}
-		return true;
-	}
-	function constructYamlPairs(data) {
-		if (data === null) return [];
-		const object = data;
-		const result = new Array(object.length);
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			const pair = object[index];
-			const keys = Object.keys(pair);
-			result[index] = [keys[0], pair[keys[0]]];
-		}
-		return result;
-	}
-	module.exports = new Type("tag:yaml.org,2002:pairs", {
-		kind: "sequence",
-		resolve: resolveYamlPairs,
-		construct: constructYamlPairs
-	});
-}));
-var require_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var Type = require_type();
-	var _hasOwnProperty = Object.prototype.hasOwnProperty;
-	function resolveYamlSet(data) {
-		if (data === null) return true;
-		const object = data;
-		for (const key in object) if (_hasOwnProperty.call(object, key)) {
-			if (object[key] !== null) return false;
-		}
-		return true;
-	}
-	function constructYamlSet(data) {
-		return data !== null ? data : {};
-	}
-	module.exports = new Type("tag:yaml.org,2002:set", {
-		kind: "mapping",
-		resolve: resolveYamlSet,
-		construct: constructYamlSet
-	});
-}));
-var require_default = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = require_core().extend({
-		implicit: [require_timestamp(), require_merge()],
-		explicit: [
-			require_binary(),
-			require_omap(),
-			require_pairs(),
-			require_set()
-		]
-	});
-}));
-var require_loader = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var common = require_common();
-	var YAMLException = require_exception();
-	var makeSnippet = require_snippet();
-	var DEFAULT_SCHEMA = require_default();
-	var _hasOwnProperty = Object.prototype.hasOwnProperty;
-	var CONTEXT_FLOW_IN = 1;
-	var CONTEXT_FLOW_OUT = 2;
-	var CONTEXT_BLOCK_IN = 3;
-	var CONTEXT_BLOCK_OUT = 4;
-	var CHOMPING_CLIP = 1;
-	var CHOMPING_STRIP = 2;
-	var CHOMPING_KEEP = 3;
-	var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-	var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
-	var PATTERN_FLOW_INDICATORS = /[,\[\]{}]/;
-	var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
-	var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
-	function _class(obj) {
-		return Object.prototype.toString.call(obj);
-	}
-	function isEol(c) {
-		return c === 10 || c === 13;
-	}
-	function isWhiteSpace(c) {
-		return c === 9 || c === 32;
-	}
-	function isWsOrEol(c) {
-		return c === 9 || c === 32 || c === 10 || c === 13;
-	}
-	function isFlowIndicator(c) {
-		return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
-	}
-	function fromHexCode(c) {
-		if (c >= 48 && c <= 57) return c - 48;
-		const lc = c | 32;
-		if (lc >= 97 && lc <= 102) return lc - 97 + 10;
-		return -1;
-	}
-	function escapedHexLen(c) {
-		if (c === 120) return 2;
-		if (c === 117) return 4;
-		if (c === 85) return 8;
-		return 0;
-	}
-	function fromDecimalCode(c) {
-		if (c >= 48 && c <= 57) return c - 48;
-		return -1;
-	}
-	function simpleEscapeSequence(c) {
-		switch (c) {
-			case 48: return "\0";
-			case 97: return "\x07";
-			case 98: return "\b";
-			case 116: return "	";
-			case 9: return "	";
-			case 110: return "\n";
-			case 118: return "\v";
-			case 102: return "\f";
-			case 114: return "\r";
-			case 101: return "\x1B";
-			case 32: return " ";
-			case 34: return "\"";
-			case 47: return "/";
-			case 92: return "\\";
-			case 78: return "…";
-			case 95: return "\xA0";
-			case 76: return "\u2028";
-			case 80: return "\u2029";
-			default: return "";
-		}
-	}
-	function charFromCodepoint(c) {
-		if (c <= 65535) return String.fromCharCode(c);
-		return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
-	}
-	function setProperty(object, key, value) {
-		if (key === "__proto__") Object.defineProperty(object, key, {
-			configurable: true,
-			enumerable: true,
-			writable: true,
-			value
-		});
-		else object[key] = value;
-	}
-	var simpleEscapeCheck = new Array(256);
-	var simpleEscapeMap = new Array(256);
-	for (let i = 0; i < 256; i++) {
-		simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
-		simpleEscapeMap[i] = simpleEscapeSequence(i);
-	}
-	function State(input, options) {
-		this.input = input;
-		this.filename = options["filename"] || null;
-		this.schema = options["schema"] || DEFAULT_SCHEMA;
-		this.onWarning = options["onWarning"] || null;
-		this.legacy = options["legacy"] || false;
-		this.json = options["json"] || false;
-		this.listener = options["listener"] || null;
-		this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100;
-		this.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20;
-		this.implicitTypes = this.schema.compiledImplicit;
-		this.typeMap = this.schema.compiledTypeMap;
-		this.length = input.length;
-		this.position = 0;
-		this.line = 0;
-		this.lineStart = 0;
-		this.lineIndent = 0;
-		this.depth = 0;
-		this.firstTabInLine = -1;
-		this.documents = [];
-		this.anchorMapTransactions = [];
-	}
-	function generateError(state, message) {
-		const mark = {
-			name: state.filename,
-			buffer: state.input.slice(0, -1),
-			position: state.position,
-			line: state.line,
-			column: state.position - state.lineStart
-		};
-		mark.snippet = makeSnippet(mark);
-		return new YAMLException(message, mark);
-	}
-	function throwError(state, message) {
-		throw generateError(state, message);
-	}
-	function throwWarning(state, message) {
-		if (state.onWarning) state.onWarning.call(null, generateError(state, message));
-	}
-	function storeAnchor(state, name, value) {
-		const transactions = state.anchorMapTransactions;
-		if (transactions.length !== 0) {
-			const transaction = transactions[transactions.length - 1];
-			if (!_hasOwnProperty.call(transaction, name)) transaction[name] = {
-				existed: _hasOwnProperty.call(state.anchorMap, name),
-				value: state.anchorMap[name]
-			};
-		}
-		state.anchorMap[name] = value;
-	}
-	function beginAnchorTransaction(state) {
-		state.anchorMapTransactions.push(Object.create(null));
-	}
-	function commitAnchorTransaction(state) {
-		const transaction = state.anchorMapTransactions.pop();
-		const transactions = state.anchorMapTransactions;
-		if (transactions.length === 0) return;
-		const parent = transactions[transactions.length - 1];
-		const names = Object.keys(transaction);
-		for (let index = 0, length = names.length; index < length; index += 1) {
-			const name = names[index];
-			if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name];
-		}
-	}
-	function rollbackAnchorTransaction(state) {
-		const transaction = state.anchorMapTransactions.pop();
-		const names = Object.keys(transaction);
-		for (let index = names.length - 1; index >= 0; index -= 1) {
-			const entry = transaction[names[index]];
-			if (entry.existed) state.anchorMap[names[index]] = entry.value;
-			else delete state.anchorMap[names[index]];
-		}
-	}
-	function snapshotState(state) {
-		return {
-			position: state.position,
-			line: state.line,
-			lineStart: state.lineStart,
-			lineIndent: state.lineIndent,
-			firstTabInLine: state.firstTabInLine,
-			tag: state.tag,
-			anchor: state.anchor,
-			kind: state.kind,
-			result: state.result
-		};
-	}
-	function restoreState(state, snapshot) {
-		state.position = snapshot.position;
-		state.line = snapshot.line;
-		state.lineStart = snapshot.lineStart;
-		state.lineIndent = snapshot.lineIndent;
-		state.firstTabInLine = snapshot.firstTabInLine;
-		state.tag = snapshot.tag;
-		state.anchor = snapshot.anchor;
-		state.kind = snapshot.kind;
-		state.result = snapshot.result;
-	}
-	var directiveHandlers = {
-		YAML: function handleYamlDirective(state, name, args) {
-			if (state.version !== null) throwError(state, "duplication of %YAML directive");
-			if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
-			const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-			if (match === null) throwError(state, "ill-formed argument of the YAML directive");
-			const major = parseInt(match[1], 10);
-			const minor = parseInt(match[2], 10);
-			if (major !== 1) throwError(state, "unacceptable YAML version of the document");
-			state.version = args[0];
-			state.checkLineBreaks = minor < 2;
-			if (minor !== 1 && minor !== 2) throwWarning(state, "unsupported YAML version of the document");
-		},
-		TAG: function handleTagDirective(state, name, args) {
-			let prefix;
-			if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
-			const handle = args[0];
-			prefix = args[1];
-			if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
-			if (_hasOwnProperty.call(state.tagMap, handle)) throwError(state, "there is a previously declared suffix for \"" + handle + "\" tag handle");
-			if (!PATTERN_TAG_URI.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
-			try {
-				prefix = decodeURIComponent(prefix);
-			} catch (err) {
-				throwError(state, "tag prefix is malformed: " + prefix);
-			}
-			state.tagMap[handle] = prefix;
-		}
-	};
-	function captureSegment(state, start, end, checkJson) {
-		if (start < end) {
-			const _result = state.input.slice(start, end);
-			if (checkJson) for (let _position = 0, _length = _result.length; _position < _length; _position += 1) {
-				const _character = _result.charCodeAt(_position);
-				if (!(_character === 9 || _character >= 32 && _character <= 1114111)) throwError(state, "expected valid JSON character");
-			}
-			else if (PATTERN_NON_PRINTABLE.test(_result)) throwError(state, "the stream contains non-printable characters");
-			state.result += _result;
-		}
-	}
-	function mergeMappings(state, destination, source, overridableKeys) {
-		if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
-		const sourceKeys = Object.keys(source);
-		for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
-			const key = sourceKeys[index];
-			if (!_hasOwnProperty.call(destination, key)) {
-				setProperty(destination, key, source[key]);
-				overridableKeys[key] = true;
-			}
-		}
-	}
-	function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
-		if (Array.isArray(keyNode)) {
-			keyNode = Array.prototype.slice.call(keyNode);
-			for (let index = 0, quantity = keyNode.length; index < quantity; index += 1) {
-				if (Array.isArray(keyNode[index])) throwError(state, "nested arrays are not supported inside keys");
-				if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") keyNode[index] = "[object Object]";
-			}
-		}
-		if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") keyNode = "[object Object]";
-		keyNode = String(keyNode);
-		if (_result === null) _result = {};
-		if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) {
-			if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
-			const seen = /* @__PURE__ */ new Set();
-			for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
-				const src = valueNode[index];
-				if (seen.has(src)) continue;
-				seen.add(src);
-				mergeMappings(state, _result, src, overridableKeys);
-			}
-		} else mergeMappings(state, _result, valueNode, overridableKeys);
-		else {
-			if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
-				state.line = startLine || state.line;
-				state.lineStart = startLineStart || state.lineStart;
-				state.position = startPos || state.position;
-				throwError(state, "duplicated mapping key");
-			}
-			setProperty(_result, keyNode, valueNode);
-			delete overridableKeys[keyNode];
-		}
-		return _result;
-	}
-	function readLineBreak(state) {
-		const ch = state.input.charCodeAt(state.position);
-		if (ch === 10) state.position++;
-		else if (ch === 13) {
-			state.position++;
-			if (state.input.charCodeAt(state.position) === 10) state.position++;
-		} else throwError(state, "a line break is expected");
-		state.line += 1;
-		state.lineStart = state.position;
-		state.firstTabInLine = -1;
-	}
-	function skipSeparationSpace(state, allowComments, checkIndent) {
-		let lineBreaks = 0;
-		let ch = state.input.charCodeAt(state.position);
-		while (ch !== 0) {
-			while (isWhiteSpace(ch)) {
-				if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
-				ch = state.input.charCodeAt(++state.position);
-			}
-			if (allowComments && ch === 35) do
-				ch = state.input.charCodeAt(++state.position);
-			while (ch !== 10 && ch !== 13 && ch !== 0);
-			if (isEol(ch)) {
-				readLineBreak(state);
-				ch = state.input.charCodeAt(state.position);
-				lineBreaks++;
-				state.lineIndent = 0;
-				while (ch === 32) {
-					state.lineIndent++;
-					ch = state.input.charCodeAt(++state.position);
-				}
-			} else break;
-		}
-		if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation");
-		return lineBreaks;
-	}
-	function testDocumentSeparator(state) {
-		let _position = state.position;
-		let ch = state.input.charCodeAt(_position);
-		if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
-			_position += 3;
-			ch = state.input.charCodeAt(_position);
-			if (ch === 0 || isWsOrEol(ch)) return true;
-		}
-		return false;
-	}
-	function writeFoldedLines(state, count) {
-		if (count === 1) state.result += " ";
-		else if (count > 1) state.result += common.repeat("\n", count - 1);
-	}
-	function readPlainScalar(state, nodeIndent, withinFlowCollection) {
-		let captureStart;
-		let captureEnd;
-		let hasPendingContent;
-		let _line;
-		let _lineStart;
-		let _lineIndent;
-		const _kind = state.kind;
-		const _result = state.result;
-		let ch = state.input.charCodeAt(state.position);
-		if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false;
-		if (ch === 63 || ch === 45) {
-			const following = state.input.charCodeAt(state.position + 1);
-			if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) return false;
-		}
-		state.kind = "scalar";
-		state.result = "";
-		captureStart = captureEnd = state.position;
-		hasPendingContent = false;
-		while (ch !== 0) {
-			if (ch === 58) {
-				const following = state.input.charCodeAt(state.position + 1);
-				if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) break;
-			} else if (ch === 35) {
-				if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break;
-			} else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) break;
-			else if (isEol(ch)) {
-				_line = state.line;
-				_lineStart = state.lineStart;
-				_lineIndent = state.lineIndent;
-				skipSeparationSpace(state, false, -1);
-				if (state.lineIndent >= nodeIndent) {
-					hasPendingContent = true;
-					ch = state.input.charCodeAt(state.position);
-					continue;
-				} else {
-					state.position = captureEnd;
-					state.line = _line;
-					state.lineStart = _lineStart;
-					state.lineIndent = _lineIndent;
-					break;
-				}
-			}
-			if (hasPendingContent) {
-				captureSegment(state, captureStart, captureEnd, false);
-				writeFoldedLines(state, state.line - _line);
-				captureStart = captureEnd = state.position;
-				hasPendingContent = false;
-			}
-			if (!isWhiteSpace(ch)) captureEnd = state.position + 1;
-			ch = state.input.charCodeAt(++state.position);
-		}
-		captureSegment(state, captureStart, captureEnd, false);
-		if (state.result) return true;
-		state.kind = _kind;
-		state.result = _result;
-		return false;
-	}
-	function readSingleQuotedScalar(state, nodeIndent) {
-		let captureStart;
-		let captureEnd;
-		let ch = state.input.charCodeAt(state.position);
-		if (ch !== 39) return false;
-		state.kind = "scalar";
-		state.result = "";
-		state.position++;
-		captureStart = captureEnd = state.position;
-		while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) {
-			captureSegment(state, captureStart, state.position, true);
-			ch = state.input.charCodeAt(++state.position);
-			if (ch === 39) {
-				captureStart = state.position;
-				state.position++;
-				captureEnd = state.position;
-			} else return true;
-		} else if (isEol(ch)) {
-			captureSegment(state, captureStart, captureEnd, true);
-			writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-			captureStart = captureEnd = state.position;
-		} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar");
-		else {
-			state.position++;
-			if (!isWhiteSpace(ch)) captureEnd = state.position;
-		}
-		throwError(state, "unexpected end of the stream within a single quoted scalar");
-	}
-	function readDoubleQuotedScalar(state, nodeIndent) {
-		let captureStart;
-		let captureEnd;
-		let tmp;
-		let ch = state.input.charCodeAt(state.position);
-		if (ch !== 34) return false;
-		state.kind = "scalar";
-		state.result = "";
-		state.position++;
-		captureStart = captureEnd = state.position;
-		while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) {
-			captureSegment(state, captureStart, state.position, true);
-			state.position++;
-			return true;
-		} else if (ch === 92) {
-			captureSegment(state, captureStart, state.position, true);
-			ch = state.input.charCodeAt(++state.position);
-			if (isEol(ch)) skipSeparationSpace(state, false, nodeIndent);
-			else if (ch < 256 && simpleEscapeCheck[ch]) {
-				state.result += simpleEscapeMap[ch];
-				state.position++;
-			} else if ((tmp = escapedHexLen(ch)) > 0) {
-				let hexLength = tmp;
-				let hexResult = 0;
-				for (; hexLength > 0; hexLength--) {
-					ch = state.input.charCodeAt(++state.position);
-					if ((tmp = fromHexCode(ch)) >= 0) hexResult = (hexResult << 4) + tmp;
-					else throwError(state, "expected hexadecimal character");
-				}
-				state.result += charFromCodepoint(hexResult);
-				state.position++;
-			} else throwError(state, "unknown escape sequence");
-			captureStart = captureEnd = state.position;
-		} else if (isEol(ch)) {
-			captureSegment(state, captureStart, captureEnd, true);
-			writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-			captureStart = captureEnd = state.position;
-		} else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar");
-		else {
-			state.position++;
-			if (!isWhiteSpace(ch)) captureEnd = state.position;
-		}
-		throwError(state, "unexpected end of the stream within a double quoted scalar");
-	}
-	function readFlowCollection(state, nodeIndent) {
-		let readNext = true;
-		let _line;
-		let _lineStart;
-		let _pos;
-		const _tag = state.tag;
-		let _result;
-		const _anchor = state.anchor;
-		let terminator;
-		let isPair;
-		let isExplicitPair;
-		let isMapping;
-		const overridableKeys = Object.create(null);
-		let keyNode;
-		let keyTag;
-		let valueNode;
-		let ch = state.input.charCodeAt(state.position);
-		if (ch === 91) {
-			terminator = 93;
-			isMapping = false;
-			_result = [];
-		} else if (ch === 123) {
-			terminator = 125;
-			isMapping = true;
-			_result = {};
-		} else return false;
-		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
-		ch = state.input.charCodeAt(++state.position);
-		while (ch !== 0) {
-			skipSeparationSpace(state, true, nodeIndent);
-			ch = state.input.charCodeAt(state.position);
-			if (ch === terminator) {
-				state.position++;
-				state.tag = _tag;
-				state.anchor = _anchor;
-				state.kind = isMapping ? "mapping" : "sequence";
-				state.result = _result;
-				return true;
-			} else if (!readNext) throwError(state, "missed comma between flow collection entries");
-			else if (ch === 44) throwError(state, "expected the node content, but found ','");
-			keyTag = keyNode = valueNode = null;
-			isPair = isExplicitPair = false;
-			if (ch === 63) {
-				if (isWsOrEol(state.input.charCodeAt(state.position + 1))) {
-					isPair = isExplicitPair = true;
-					state.position++;
-					skipSeparationSpace(state, true, nodeIndent);
-				}
-			}
-			_line = state.line;
-			_lineStart = state.lineStart;
-			_pos = state.position;
-			composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-			keyTag = state.tag;
-			keyNode = state.result;
-			skipSeparationSpace(state, true, nodeIndent);
-			ch = state.input.charCodeAt(state.position);
-			if ((isExplicitPair || state.line === _line) && ch === 58) {
-				isPair = true;
-				ch = state.input.charCodeAt(++state.position);
-				skipSeparationSpace(state, true, nodeIndent);
-				composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-				valueNode = state.result;
-			}
-			if (isMapping) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
-			else if (isPair) _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
-			else _result.push(keyNode);
-			skipSeparationSpace(state, true, nodeIndent);
-			ch = state.input.charCodeAt(state.position);
-			if (ch === 44) {
-				readNext = true;
-				ch = state.input.charCodeAt(++state.position);
-			} else readNext = false;
-		}
-		throwError(state, "unexpected end of the stream within a flow collection");
-	}
-	function readBlockScalar(state, nodeIndent) {
-		let folding;
-		let chomping = CHOMPING_CLIP;
-		let didReadContent = false;
-		let detectedIndent = false;
-		let textIndent = nodeIndent;
-		let emptyLines = 0;
-		let atMoreIndented = false;
-		let tmp;
-		let ch = state.input.charCodeAt(state.position);
-		if (ch === 124) folding = false;
-		else if (ch === 62) folding = true;
-		else return false;
-		state.kind = "scalar";
-		state.result = "";
-		while (ch !== 0) {
-			ch = state.input.charCodeAt(++state.position);
-			if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
-			else throwError(state, "repeat of a chomping mode identifier");
-			else if ((tmp = fromDecimalCode(ch)) >= 0) if (tmp === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
-			else if (!detectedIndent) {
-				textIndent = nodeIndent + tmp - 1;
-				detectedIndent = true;
-			} else throwError(state, "repeat of an indentation width identifier");
-			else break;
-		}
-		if (isWhiteSpace(ch)) {
-			do
-				ch = state.input.charCodeAt(++state.position);
-			while (isWhiteSpace(ch));
-			if (ch === 35) do
-				ch = state.input.charCodeAt(++state.position);
-			while (!isEol(ch) && ch !== 0);
-		}
-		while (ch !== 0) {
-			readLineBreak(state);
-			state.lineIndent = 0;
-			ch = state.input.charCodeAt(state.position);
-			while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
-				state.lineIndent++;
-				ch = state.input.charCodeAt(++state.position);
-			}
-			if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
-			if (isEol(ch)) {
-				emptyLines++;
-				continue;
-			}
-			if (!detectedIndent && textIndent === 0) throwError(state, "missing indentation for block scalar");
-			if (state.lineIndent < textIndent) {
-				if (chomping === CHOMPING_KEEP) state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-				else if (chomping === CHOMPING_CLIP) {
-					if (didReadContent) state.result += "\n";
-				}
-				break;
-			}
-			if (folding) if (isWhiteSpace(ch)) {
-				atMoreIndented = true;
-				state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-			} else if (atMoreIndented) {
-				atMoreIndented = false;
-				state.result += common.repeat("\n", emptyLines + 1);
-			} else if (emptyLines === 0) {
-				if (didReadContent) state.result += " ";
-			} else state.result += common.repeat("\n", emptyLines);
-			else state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-			didReadContent = true;
-			detectedIndent = true;
-			emptyLines = 0;
-			const captureStart = state.position;
-			while (!isEol(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position);
-			captureSegment(state, captureStart, state.position, false);
-		}
-		return true;
-	}
-	function readBlockSequence(state, nodeIndent) {
-		const _tag = state.tag;
-		const _anchor = state.anchor;
-		const _result = [];
-		let detected = false;
-		if (state.firstTabInLine !== -1) return false;
-		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
-		let ch = state.input.charCodeAt(state.position);
-		while (ch !== 0) {
-			if (state.firstTabInLine !== -1) {
-				state.position = state.firstTabInLine;
-				throwError(state, "tab characters must not be used in indentation");
-			}
-			if (ch !== 45) break;
-			if (!isWsOrEol(state.input.charCodeAt(state.position + 1))) break;
-			detected = true;
-			state.position++;
-			if (skipSeparationSpace(state, true, -1)) {
-				if (state.lineIndent <= nodeIndent) {
-					_result.push(null);
-					ch = state.input.charCodeAt(state.position);
-					continue;
-				}
-			}
-			const _line = state.line;
-			composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
-			_result.push(state.result);
-			skipSeparationSpace(state, true, -1);
-			ch = state.input.charCodeAt(state.position);
-			if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a sequence entry");
-			else if (state.lineIndent < nodeIndent) break;
-		}
-		if (detected) {
-			state.tag = _tag;
-			state.anchor = _anchor;
-			state.kind = "sequence";
-			state.result = _result;
-			return true;
-		}
-		return false;
-	}
-	function readBlockMapping(state, nodeIndent, flowIndent) {
-		let allowCompact;
-		let _keyLine;
-		let _keyLineStart;
-		let _keyPos;
-		const _tag = state.tag;
-		const _anchor = state.anchor;
-		const _result = {};
-		const overridableKeys = Object.create(null);
-		let keyTag = null;
-		let keyNode = null;
-		let valueNode = null;
-		let atExplicitKey = false;
-		let detected = false;
-		if (state.firstTabInLine !== -1) return false;
-		if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
-		let ch = state.input.charCodeAt(state.position);
-		while (ch !== 0) {
-			if (!atExplicitKey && state.firstTabInLine !== -1) {
-				state.position = state.firstTabInLine;
-				throwError(state, "tab characters must not be used in indentation");
-			}
-			const following = state.input.charCodeAt(state.position + 1);
-			const _line = state.line;
-			if ((ch === 63 || ch === 58) && isWsOrEol(following)) {
-				if (ch === 63) {
-					if (atExplicitKey) {
-						storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-						keyTag = keyNode = valueNode = null;
-					}
-					detected = true;
-					atExplicitKey = true;
-					allowCompact = true;
-				} else if (atExplicitKey) {
-					atExplicitKey = false;
-					allowCompact = true;
-				} else throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
-				state.position += 1;
-				ch = following;
-			} else {
-				_keyLine = state.line;
-				_keyLineStart = state.lineStart;
-				_keyPos = state.position;
-				if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
-				if (state.line === _line) {
-					ch = state.input.charCodeAt(state.position);
-					while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
-					if (ch === 58) {
-						ch = state.input.charCodeAt(++state.position);
-						if (!isWsOrEol(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
-						if (atExplicitKey) {
-							storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-							keyTag = keyNode = valueNode = null;
-						}
-						detected = true;
-						atExplicitKey = false;
-						allowCompact = false;
-						keyTag = state.tag;
-						keyNode = state.result;
-					} else if (detected) throwError(state, "can not read an implicit mapping pair; a colon is missed");
-					else {
-						state.tag = _tag;
-						state.anchor = _anchor;
-						return true;
-					}
-				} else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
-				else {
-					state.tag = _tag;
-					state.anchor = _anchor;
-					return true;
-				}
-			}
-			if (state.line === _line || state.lineIndent > nodeIndent) {
-				if (atExplicitKey) {
-					_keyLine = state.line;
-					_keyLineStart = state.lineStart;
-					_keyPos = state.position;
-				}
-				if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) if (atExplicitKey) keyNode = state.result;
-				else valueNode = state.result;
-				if (!atExplicitKey) {
-					storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
-					keyTag = keyNode = valueNode = null;
-				}
-				skipSeparationSpace(state, true, -1);
-				ch = state.input.charCodeAt(state.position);
-			}
-			if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry");
-			else if (state.lineIndent < nodeIndent) break;
-		}
-		if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-		if (detected) {
-			state.tag = _tag;
-			state.anchor = _anchor;
-			state.kind = "mapping";
-			state.result = _result;
-		}
-		return detected;
-	}
-	function readTagProperty(state) {
-		let isVerbatim = false;
-		let isNamed = false;
-		let tagHandle;
-		let tagName;
-		let ch = state.input.charCodeAt(state.position);
-		if (ch !== 33) return false;
-		if (state.tag !== null) throwError(state, "duplication of a tag property");
-		ch = state.input.charCodeAt(++state.position);
-		if (ch === 60) {
-			isVerbatim = true;
-			ch = state.input.charCodeAt(++state.position);
-		} else if (ch === 33) {
-			isNamed = true;
-			tagHandle = "!!";
-			ch = state.input.charCodeAt(++state.position);
-		} else tagHandle = "!";
-		let _position = state.position;
-		if (isVerbatim) {
-			do
-				ch = state.input.charCodeAt(++state.position);
-			while (ch !== 0 && ch !== 62);
-			if (state.position < state.length) {
-				tagName = state.input.slice(_position, state.position);
-				ch = state.input.charCodeAt(++state.position);
-			} else throwError(state, "unexpected end of the stream within a verbatim tag");
-		} else {
-			while (ch !== 0 && !isWsOrEol(ch)) {
-				if (ch === 33) if (!isNamed) {
-					tagHandle = state.input.slice(_position - 1, state.position + 1);
-					if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters");
-					isNamed = true;
-					_position = state.position + 1;
-				} else throwError(state, "tag suffix cannot contain exclamation marks");
-				ch = state.input.charCodeAt(++state.position);
-			}
-			tagName = state.input.slice(_position, state.position);
-			if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters");
-		}
-		if (tagName && !PATTERN_TAG_URI.test(tagName)) throwError(state, "tag name cannot contain such characters: " + tagName);
-		try {
-			tagName = decodeURIComponent(tagName);
-		} catch (err) {
-			throwError(state, "tag name is malformed: " + tagName);
-		}
-		if (isVerbatim) state.tag = tagName;
-		else if (_hasOwnProperty.call(state.tagMap, tagHandle)) state.tag = state.tagMap[tagHandle] + tagName;
-		else if (tagHandle === "!") state.tag = "!" + tagName;
-		else if (tagHandle === "!!") state.tag = "tag:yaml.org,2002:" + tagName;
-		else throwError(state, "undeclared tag handle \"" + tagHandle + "\"");
-		return true;
-	}
-	function readAnchorProperty(state) {
-		let ch = state.input.charCodeAt(state.position);
-		if (ch !== 38) return false;
-		if (state.anchor !== null) throwError(state, "duplication of an anchor property");
-		ch = state.input.charCodeAt(++state.position);
-		const _position = state.position;
-		while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
-		if (state.position === _position) throwError(state, "name of an anchor node must contain at least one character");
-		state.anchor = state.input.slice(_position, state.position);
-		return true;
-	}
-	function readAlias(state) {
-		let ch = state.input.charCodeAt(state.position);
-		if (ch !== 42) return false;
-		ch = state.input.charCodeAt(++state.position);
-		const _position = state.position;
-		while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
-		if (state.position === _position) throwError(state, "name of an alias node must contain at least one character");
-		const alias = state.input.slice(_position, state.position);
-		if (!_hasOwnProperty.call(state.anchorMap, alias)) throwError(state, "unidentified alias \"" + alias + "\"");
-		state.result = state.anchorMap[alias];
-		skipSeparationSpace(state, true, -1);
-		return true;
-	}
-	function tryReadBlockMappingFromProperty(state, propertyStart, nodeIndent, flowIndent) {
-		const fallbackState = snapshotState(state);
-		beginAnchorTransaction(state);
-		restoreState(state, propertyStart);
-		state.tag = null;
-		state.anchor = null;
-		state.kind = null;
-		state.result = null;
-		if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === "mapping") {
-			commitAnchorTransaction(state);
-			return true;
-		}
-		rollbackAnchorTransaction(state);
-		restoreState(state, fallbackState);
-		return false;
-	}
-	function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
-		let allowBlockScalars;
-		let allowBlockCollections;
-		let indentStatus = 1;
-		let atNewLine = false;
-		let hasContent = false;
-		let propertyStart = null;
-		let type;
-		let flowIndent;
-		let blockIndent;
-		if (state.depth >= state.maxDepth) throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")");
-		state.depth += 1;
-		if (state.listener !== null) state.listener("open", state);
-		state.tag = null;
-		state.anchor = null;
-		state.kind = null;
-		state.result = null;
-		const allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
-		if (allowToSeek) {
-			if (skipSeparationSpace(state, true, -1)) {
-				atNewLine = true;
-				if (state.lineIndent > parentIndent) indentStatus = 1;
-				else if (state.lineIndent === parentIndent) indentStatus = 0;
-				else if (state.lineIndent < parentIndent) indentStatus = -1;
-			}
-		}
-		if (indentStatus === 1) while (true) {
-			const ch = state.input.charCodeAt(state.position);
-			const propertyState = snapshotState(state);
-			if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) break;
-			if (!readTagProperty(state) && !readAnchorProperty(state)) break;
-			if (propertyStart === null) propertyStart = propertyState;
-			if (skipSeparationSpace(state, true, -1)) {
-				atNewLine = true;
-				allowBlockCollections = allowBlockStyles;
-				if (state.lineIndent > parentIndent) indentStatus = 1;
-				else if (state.lineIndent === parentIndent) indentStatus = 0;
-				else if (state.lineIndent < parentIndent) indentStatus = -1;
-			} else allowBlockCollections = false;
-		}
-		if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
-		if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
-			if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) flowIndent = parentIndent;
-			else flowIndent = parentIndent + 1;
-			blockIndent = state.position - state.lineStart;
-			if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) hasContent = true;
-			else {
-				const ch = state.input.charCodeAt(state.position);
-				if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, flowIndent)) hasContent = true;
-				else if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) hasContent = true;
-				else if (readAlias(state)) {
-					hasContent = true;
-					if (state.tag !== null || state.anchor !== null) throwError(state, "alias node should not have any properties");
-				} else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
-					hasContent = true;
-					if (state.tag === null) state.tag = "?";
-				}
-				if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
-			}
-			else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
-		}
-		if (state.tag === null) {
-			if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
-		} else if (state.tag === "?") {
-			if (state.result !== null && state.kind !== "scalar") throwError(state, "unacceptable node kind for !<?> tag; it should be \"scalar\", not \"" + state.kind + "\"");
-			for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
-				type = state.implicitTypes[typeIndex];
-				if (type.resolve(state.result)) {
-					state.result = type.construct(state.result);
-					state.tag = type.tag;
-					if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
-					break;
-				}
-			}
-		} else if (state.tag !== "!") {
-			if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) type = state.typeMap[state.kind || "fallback"][state.tag];
-			else {
-				type = null;
-				const typeList = state.typeMap.multi[state.kind || "fallback"];
-				for (let typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
-					type = typeList[typeIndex];
-					break;
-				}
-			}
-			if (!type) throwError(state, "unknown tag !<" + state.tag + ">");
-			if (state.result !== null && type.kind !== state.kind) throwError(state, "unacceptable node kind for !<" + state.tag + "> tag; it should be \"" + type.kind + "\", not \"" + state.kind + "\"");
-			if (!type.resolve(state.result, state.tag)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
-			else {
-				state.result = type.construct(state.result, state.tag);
-				if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
-			}
-		}
-		if (state.listener !== null) state.listener("close", state);
-		state.depth -= 1;
-		return state.tag !== null || state.anchor !== null || hasContent;
-	}
-	function readDocument(state) {
-		const documentStart = state.position;
-		let hasDirectives = false;
-		let ch;
-		state.version = null;
-		state.checkLineBreaks = state.legacy;
-		state.tagMap = Object.create(null);
-		state.anchorMap = Object.create(null);
-		while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-			skipSeparationSpace(state, true, -1);
-			ch = state.input.charCodeAt(state.position);
-			if (state.lineIndent > 0 || ch !== 37) break;
-			hasDirectives = true;
-			ch = state.input.charCodeAt(++state.position);
-			let _position = state.position;
-			while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
-			const directiveName = state.input.slice(_position, state.position);
-			const directiveArgs = [];
-			if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length");
-			while (ch !== 0) {
-				while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
-				if (ch === 35) {
-					do
-						ch = state.input.charCodeAt(++state.position);
-					while (ch !== 0 && !isEol(ch));
-					break;
-				}
-				if (isEol(ch)) break;
-				_position = state.position;
-				while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
-				directiveArgs.push(state.input.slice(_position, state.position));
-			}
-			if (ch !== 0) readLineBreak(state);
-			if (_hasOwnProperty.call(directiveHandlers, directiveName)) directiveHandlers[directiveName](state, directiveName, directiveArgs);
-			else throwWarning(state, "unknown document directive \"" + directiveName + "\"");
-		}
-		skipSeparationSpace(state, true, -1);
-		if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
-			state.position += 3;
-			skipSeparationSpace(state, true, -1);
-		} else if (hasDirectives) throwError(state, "directives end mark is expected");
-		composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
-		skipSeparationSpace(state, true, -1);
-		if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) throwWarning(state, "non-ASCII line breaks are interpreted as content");
-		state.documents.push(state.result);
-		if (state.position === state.lineStart && testDocumentSeparator(state)) {
-			if (state.input.charCodeAt(state.position) === 46) {
-				state.position += 3;
-				skipSeparationSpace(state, true, -1);
-			}
-			return;
-		}
-		if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected");
-	}
-	function loadDocuments(input, options) {
-		input = String(input);
-		options = options || {};
-		if (input.length !== 0) {
-			if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n";
-			if (input.charCodeAt(0) === 65279) input = input.slice(1);
-		}
-		const state = new State(input, options);
-		const nullpos = input.indexOf("\0");
-		if (nullpos !== -1) {
-			state.position = nullpos;
-			throwError(state, "null byte is not allowed in input");
-		}
-		state.input += "\0";
-		while (state.input.charCodeAt(state.position) === 32) {
-			state.lineIndent += 1;
-			state.position += 1;
-		}
-		while (state.position < state.length - 1) readDocument(state);
-		return state.documents;
-	}
-	function loadAll(input, iterator, options) {
-		if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
-			options = iterator;
-			iterator = null;
-		}
-		const documents = loadDocuments(input, options);
-		if (typeof iterator !== "function") return documents;
-		for (let index = 0, length = documents.length; index < length; index += 1) iterator(documents[index]);
-	}
-	function load(input, options) {
-		const documents = loadDocuments(input, options);
-		if (documents.length === 0) return;
-		else if (documents.length === 1) return documents[0];
-		throw new YAMLException("expected a single document in the stream, but found more");
-	}
-	module.exports.loadAll = loadAll;
-	module.exports.load = load;
-}));
-var require_dumper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var common = require_common();
-	var YAMLException = require_exception();
-	var DEFAULT_SCHEMA = require_default();
-	var _toString = Object.prototype.toString;
-	var _hasOwnProperty = Object.prototype.hasOwnProperty;
-	var CHAR_BOM = 65279;
-	var CHAR_TAB = 9;
-	var CHAR_LINE_FEED = 10;
-	var CHAR_CARRIAGE_RETURN = 13;
-	var CHAR_SPACE = 32;
-	var CHAR_EXCLAMATION = 33;
-	var CHAR_DOUBLE_QUOTE = 34;
-	var CHAR_SHARP = 35;
-	var CHAR_PERCENT = 37;
-	var CHAR_AMPERSAND = 38;
-	var CHAR_SINGLE_QUOTE = 39;
-	var CHAR_ASTERISK = 42;
-	var CHAR_COMMA = 44;
-	var CHAR_MINUS = 45;
-	var CHAR_COLON = 58;
-	var CHAR_EQUALS = 61;
-	var CHAR_GREATER_THAN = 62;
-	var CHAR_QUESTION = 63;
-	var CHAR_COMMERCIAL_AT = 64;
-	var CHAR_LEFT_SQUARE_BRACKET = 91;
-	var CHAR_RIGHT_SQUARE_BRACKET = 93;
-	var CHAR_GRAVE_ACCENT = 96;
-	var CHAR_LEFT_CURLY_BRACKET = 123;
-	var CHAR_VERTICAL_LINE = 124;
-	var CHAR_RIGHT_CURLY_BRACKET = 125;
-	var ESCAPE_SEQUENCES = {};
-	ESCAPE_SEQUENCES[0] = "\\0";
-	ESCAPE_SEQUENCES[7] = "\\a";
-	ESCAPE_SEQUENCES[8] = "\\b";
-	ESCAPE_SEQUENCES[9] = "\\t";
-	ESCAPE_SEQUENCES[10] = "\\n";
-	ESCAPE_SEQUENCES[11] = "\\v";
-	ESCAPE_SEQUENCES[12] = "\\f";
-	ESCAPE_SEQUENCES[13] = "\\r";
-	ESCAPE_SEQUENCES[27] = "\\e";
-	ESCAPE_SEQUENCES[34] = "\\\"";
-	ESCAPE_SEQUENCES[92] = "\\\\";
-	ESCAPE_SEQUENCES[133] = "\\N";
-	ESCAPE_SEQUENCES[160] = "\\_";
-	ESCAPE_SEQUENCES[8232] = "\\L";
-	ESCAPE_SEQUENCES[8233] = "\\P";
-	var DEPRECATED_BOOLEANS_SYNTAX = [
-		"y",
-		"Y",
-		"yes",
-		"Yes",
-		"YES",
-		"on",
-		"On",
-		"ON",
-		"n",
-		"N",
-		"no",
-		"No",
-		"NO",
-		"off",
-		"Off",
-		"OFF"
-	];
-	var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-	function compileStyleMap(schema, map) {
-		if (map === null) return {};
-		const result = {};
-		const keys = Object.keys(map);
-		for (let index = 0, length = keys.length; index < length; index += 1) {
-			let tag = keys[index];
-			let style = String(map[tag]);
-			if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
-			const type = schema.compiledTypeMap["fallback"][tag];
-			if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style];
-			result[tag] = style;
-		}
-		return result;
-	}
-	function encodeHex(character) {
-		let handle;
-		let length;
-		const string = character.toString(16).toUpperCase();
-		if (character <= 255) {
-			handle = "x";
-			length = 2;
-		} else if (character <= 65535) {
-			handle = "u";
-			length = 4;
-		} else if (character <= 4294967295) {
-			handle = "U";
-			length = 8;
-		} else throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
-		return "\\" + handle + common.repeat("0", length - string.length) + string;
-	}
-	var QUOTING_TYPE_SINGLE = 1;
-	var QUOTING_TYPE_DOUBLE = 2;
-	function State(options) {
-		this.schema = options["schema"] || DEFAULT_SCHEMA;
-		this.indent = Math.max(1, options["indent"] || 2);
-		this.noArrayIndent = options["noArrayIndent"] || false;
-		this.skipInvalid = options["skipInvalid"] || false;
-		this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
-		this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
-		this.sortKeys = options["sortKeys"] || false;
-		this.lineWidth = options["lineWidth"] || 80;
-		this.noRefs = options["noRefs"] || false;
-		this.noCompatMode = options["noCompatMode"] || false;
-		this.condenseFlow = options["condenseFlow"] || false;
-		this.quotingType = options["quotingType"] === "\"" ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
-		this.forceQuotes = options["forceQuotes"] || false;
-		this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null;
-		this.implicitTypes = this.schema.compiledImplicit;
-		this.explicitTypes = this.schema.compiledExplicit;
-		this.tag = null;
-		this.result = "";
-		this.duplicates = [];
-		this.usedDuplicates = null;
-	}
-	function indentString(string, spaces) {
-		const ind = common.repeat(" ", spaces);
-		let position = 0;
-		let result = "";
-		const length = string.length;
-		while (position < length) {
-			let line;
-			const next = string.indexOf("\n", position);
-			if (next === -1) {
-				line = string.slice(position);
-				position = length;
-			} else {
-				line = string.slice(position, next + 1);
-				position = next + 1;
-			}
-			if (line.length && line !== "\n") result += ind;
-			result += line;
-		}
-		return result;
-	}
-	function generateNextLine(state, level) {
-		return "\n" + common.repeat(" ", state.indent * level);
-	}
-	function testImplicitResolving(state, str) {
-		for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str)) return true;
-		return false;
-	}
-	function isWhitespace(c) {
-		return c === CHAR_SPACE || c === CHAR_TAB;
-	}
-	function isPrintable(c) {
-		return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111;
-	}
-	function isNsCharOrWhitespace(c) {
-		return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
-	}
-	function isPlainSafe(c, prev, inblock) {
-		const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
-		const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
-		return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
-	}
-	function isPlainSafeFirst(c) {
-		return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
-	}
-	function isPlainSafeLast(c) {
-		return !isWhitespace(c) && c !== CHAR_COLON;
-	}
-	function codePointAt(string, pos) {
-		const first = string.charCodeAt(pos);
-		let second;
-		if (first >= 55296 && first <= 56319 && pos + 1 < string.length) {
-			second = string.charCodeAt(pos + 1);
-			if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
-		}
-		return first;
-	}
-	function needIndentIndicator(string) {
-		return /^\n* /.test(string);
-	}
-	var STYLE_PLAIN = 1;
-	var STYLE_SINGLE = 2;
-	var STYLE_LITERAL = 3;
-	var STYLE_FOLDED = 4;
-	var STYLE_DOUBLE = 5;
-	function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
-		let i;
-		let char = 0;
-		let prevChar = null;
-		let hasLineBreak = false;
-		let hasFoldableLine = false;
-		const shouldTrackWidth = lineWidth !== -1;
-		let previousLineBreak = -1;
-		let plain = isPlainSafeFirst(codePointAt(string, 0)) && isPlainSafeLast(codePointAt(string, string.length - 1));
-		if (singleLineOnly || forceQuotes) for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
-			char = codePointAt(string, i);
-			if (!isPrintable(char)) return STYLE_DOUBLE;
-			plain = plain && isPlainSafe(char, prevChar, inblock);
-			prevChar = char;
-		}
-		else {
-			for (i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
-				char = codePointAt(string, i);
-				if (char === CHAR_LINE_FEED) {
-					hasLineBreak = true;
-					if (shouldTrackWidth) {
-						hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
-						previousLineBreak = i;
-					}
-				} else if (!isPrintable(char)) return STYLE_DOUBLE;
-				plain = plain && isPlainSafe(char, prevChar, inblock);
-				prevChar = char;
-			}
-			hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== " ";
-		}
-		if (!hasLineBreak && !hasFoldableLine) {
-			if (plain && !forceQuotes && !testAmbiguousType(string)) return STYLE_PLAIN;
-			return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-		}
-		if (indentPerLevel > 9 && needIndentIndicator(string)) return STYLE_DOUBLE;
-		if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-		return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-	}
-	function writeScalar(state, string, level, iskey, inblock) {
-		state.dump = function() {
-			if (string.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"\"" : "''";
-			if (!state.noCompatMode) {
-				if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) return state.quotingType === QUOTING_TYPE_DOUBLE ? "\"" + string + "\"" : "'" + string + "'";
-			}
-			const indent = state.indent * Math.max(1, level);
-			const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-			const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
-			function testAmbiguity(string) {
-				return testImplicitResolving(state, string);
-			}
-			switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
-				case STYLE_PLAIN: return string;
-				case STYLE_SINGLE: return "'" + string.replace(/'/g, "''") + "'";
-				case STYLE_LITERAL: return "|" + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
-				case STYLE_FOLDED: return ">" + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
-				case STYLE_DOUBLE: return "\"" + escapeString(string, lineWidth) + "\"";
-				default: throw new YAMLException("impossible error: invalid scalar style");
-			}
-		}();
-	}
-	function blockHeader(string, indentPerLevel) {
-		const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
-		const clip = string[string.length - 1] === "\n";
-		return indentIndicator + (clip && (string[string.length - 2] === "\n" || string === "\n") ? "+" : clip ? "" : "-") + "\n";
-	}
-	function dropEndingNewline(string) {
-		return string[string.length - 1] === "\n" ? string.slice(0, -1) : string;
-	}
-	function foldString(string, width) {
-		const lineRe = /(\n+)([^\n]*)/g;
-		let result = function() {
-			let nextLF = string.indexOf("\n");
-			nextLF = nextLF !== -1 ? nextLF : string.length;
-			lineRe.lastIndex = nextLF;
-			return foldLine(string.slice(0, nextLF), width);
-		}();
-		let prevMoreIndented = string[0] === "\n" || string[0] === " ";
-		let moreIndented;
-		let match;
-		while (match = lineRe.exec(string)) {
-			const prefix = match[1];
-			const line = match[2];
-			moreIndented = line[0] === " ";
-			result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
-			prevMoreIndented = moreIndented;
-		}
-		return result;
-	}
-	function foldLine(line, width) {
-		if (line === "" || line[0] === " ") return line;
-		const breakRe = / [^ ]/g;
-		let match;
-		let start = 0;
-		let end;
-		let curr = 0;
-		let next = 0;
-		let result = "";
-		while (match = breakRe.exec(line)) {
-			next = match.index;
-			if (next - start > width) {
-				end = curr > start ? curr : next;
-				result += "\n" + line.slice(start, end);
-				start = end + 1;
-			}
-			curr = next;
-		}
-		result += "\n";
-		if (line.length - start > width && curr > start) result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
-		else result += line.slice(start);
-		return result.slice(1);
-	}
-	function escapeString(string) {
-		let result = "";
-		let char = 0;
-		for (let i = 0; i < string.length; char >= 65536 ? i += 2 : i++) {
-			char = codePointAt(string, i);
-			const escapeSeq = ESCAPE_SEQUENCES[char];
-			if (!escapeSeq && isPrintable(char)) {
-				result += string[i];
-				if (char >= 65536) result += string[i + 1];
-			} else result += escapeSeq || encodeHex(char);
-		}
-		return result;
-	}
-	function writeFlowSequence(state, level, object) {
-		let _result = "";
-		const _tag = state.tag;
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			let value = object[index];
-			if (state.replacer) value = state.replacer.call(object, String(index), value);
-			if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
-				if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
-				_result += state.dump;
-			}
-		}
-		state.tag = _tag;
-		state.dump = "[" + _result + "]";
-	}
-	function writeBlockSequence(state, level, object, compact) {
-		let _result = "";
-		const _tag = state.tag;
-		for (let index = 0, length = object.length; index < length; index += 1) {
-			let value = object[index];
-			if (state.replacer) value = state.replacer.call(object, String(index), value);
-			if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
-				if (!compact || _result !== "") _result += generateNextLine(state, level);
-				if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) _result += "-";
-				else _result += "- ";
-				_result += state.dump;
-			}
-		}
-		state.tag = _tag;
-		state.dump = _result || "[]";
-	}
-	function writeFlowMapping(state, level, object) {
-		let _result = "";
-		const _tag = state.tag;
-		const objectKeyList = Object.keys(object);
-		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
-			let pairBuffer = "";
-			if (_result !== "") pairBuffer += ", ";
-			if (state.condenseFlow) pairBuffer += "\"";
-			const objectKey = objectKeyList[index];
-			let objectValue = object[objectKey];
-			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-			if (!writeNode(state, level, objectKey, false, false)) continue;
-			if (state.dump.length > 1024) pairBuffer += "? ";
-			pairBuffer += state.dump + (state.condenseFlow ? "\"" : "") + ":" + (state.condenseFlow ? "" : " ");
-			if (!writeNode(state, level, objectValue, false, false)) continue;
-			pairBuffer += state.dump;
-			_result += pairBuffer;
-		}
-		state.tag = _tag;
-		state.dump = "{" + _result + "}";
-	}
-	function writeBlockMapping(state, level, object, compact) {
-		let _result = "";
-		const _tag = state.tag;
-		const objectKeyList = Object.keys(object);
-		if (state.sortKeys === true) objectKeyList.sort();
-		else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
-		else if (state.sortKeys) throw new YAMLException("sortKeys must be a boolean or a function");
-		for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
-			let pairBuffer = "";
-			if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
-			const objectKey = objectKeyList[index];
-			let objectValue = object[objectKey];
-			if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-			if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
-			const explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
-			if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
-			else pairBuffer += "? ";
-			pairBuffer += state.dump;
-			if (explicitPair) pairBuffer += generateNextLine(state, level);
-			if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
-			if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
-			else pairBuffer += ": ";
-			pairBuffer += state.dump;
-			_result += pairBuffer;
-		}
-		state.tag = _tag;
-		state.dump = _result || "{}";
-	}
-	function detectType(state, object, explicit) {
-		const typeList = explicit ? state.explicitTypes : state.implicitTypes;
-		for (let index = 0, length = typeList.length; index < length; index += 1) {
-			const type = typeList[index];
-			if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
-				if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
-				else state.tag = type.tag;
-				else state.tag = "?";
-				if (type.represent) {
-					const style = state.styleMap[type.tag] || type.defaultStyle;
-					let _result;
-					if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
-					else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
-					else throw new YAMLException("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
-					state.dump = _result;
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-	function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-		state.tag = null;
-		state.dump = object;
-		if (!detectType(state, object, false)) detectType(state, object, true);
-		const type = _toString.call(state.dump);
-		const inblock = block;
-		if (block) block = state.flowLevel < 0 || state.flowLevel > level;
-		const objectOrArray = type === "[object Object]" || type === "[object Array]";
-		let duplicateIndex;
-		let duplicate;
-		if (objectOrArray) {
-			duplicateIndex = state.duplicates.indexOf(object);
-			duplicate = duplicateIndex !== -1;
-		}
-		if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
-		if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
-		else {
-			if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
-			if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
-				writeBlockMapping(state, level, state.dump, compact);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-			} else {
-				writeFlowMapping(state, level, state.dump);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-			}
-			else if (type === "[object Array]") if (block && state.dump.length !== 0) {
-				if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
-				else writeBlockSequence(state, level, state.dump, compact);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-			} else {
-				writeFlowSequence(state, level, state.dump);
-				if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-			}
-			else if (type === "[object String]") {
-				if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
-			} else if (type === "[object Undefined]") return false;
-			else {
-				if (state.skipInvalid) return false;
-				throw new YAMLException("unacceptable kind of an object to dump " + type);
-			}
-			if (state.tag !== null && state.tag !== "?") {
-				let tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
-				if (state.tag[0] === "!") tagStr = "!" + tagStr;
-				else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
-				else tagStr = "!<" + tagStr + ">";
-				state.dump = tagStr + " " + state.dump;
-			}
-		}
-		return true;
-	}
-	function getDuplicateReferences(object, state) {
-		const objects = [];
-		const duplicatesIndexes = [];
-		inspectNode(object, objects, duplicatesIndexes);
-		const length = duplicatesIndexes.length;
-		for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
-		state.usedDuplicates = new Array(length);
-	}
-	function inspectNode(object, objects, duplicatesIndexes) {
-		if (object !== null && typeof object === "object") {
-			const index = objects.indexOf(object);
-			if (index !== -1) {
-				if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
-			} else {
-				objects.push(object);
-				if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
-				else {
-					const objectKeyList = Object.keys(object);
-					for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
-				}
-			}
-		}
-	}
-	function dump(input, options) {
-		options = options || {};
-		const state = new State(options);
-		if (!state.noRefs) getDuplicateReferences(input, state);
-		let value = input;
-		if (state.replacer) value = state.replacer.call({ "": value }, "", value);
-		if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
-		return "";
-	}
-	module.exports.dump = dump;
-}));
-var import_js_yaml = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var loader = require_loader();
-	var dumper = require_dumper();
-	function renamed(from, to) {
-		return function() {
-			throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
-		};
-	}
-	module.exports.Type = require_type();
-	module.exports.Schema = require_schema();
-	module.exports.FAILSAFE_SCHEMA = require_failsafe();
-	module.exports.JSON_SCHEMA = require_json();
-	module.exports.CORE_SCHEMA = require_core();
-	module.exports.DEFAULT_SCHEMA = require_default();
-	module.exports.load = loader.load;
-	module.exports.loadAll = loader.loadAll;
-	module.exports.dump = dumper.dump;
-	module.exports.YAMLException = require_exception();
-	module.exports.types = {
-		binary: require_binary(),
-		float: require_float(),
-		map: require_map(),
-		null: require_null(),
-		pairs: require_pairs(),
-		set: require_set(),
-		timestamp: require_timestamp(),
-		bool: require_bool(),
-		int: require_int(),
-		merge: require_merge(),
-		omap: require_omap(),
-		seq: require_seq(),
-		str: require_str()
-	};
-	module.exports.safeLoad = renamed("safeLoad", "load");
-	module.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
-	module.exports.safeDump = renamed("safeDump", "dump");
-})))(), 1);
-var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
-import_js_yaml.default;
-//#endregion
-//#region ../evolution-core/src/skill-store.ts
-/**
-* Map a requesting session onto the two origin surfaces (rc.44 plan M2-2.3):
-* the APPROVAL surface treats every delegated subagent as the autonomous
-* review channel, while the LIBRARY surface keeps the Hermes distinction -
-* the review fork is 'background_review' (the pinned guard blocks its
-* writes) and any other subagent is 'subagent' (agent-authored, not
-* review-channel). `isReview` marks the caller as the background review
-* pipeline itself. Single source: the two tools and the review executor all
-* read this table instead of re-deriving it.
-*/
-function resolveOrigins(headerOrigin, isReview = false) {
-	if (isReview) return {
-		approval: "background_review",
-		library: "background_review"
-	};
-	if (headerOrigin === "subagent") return {
-		approval: "background_review",
-		library: "subagent"
-	};
-	return {
-		approval: "foreground",
-		library: "foreground"
-	};
-}
-//#endregion
+import { resolveOrigins } from "@lmzhen/dsh-evolution-core";
 //#region lib/types/index.js
 /**
 * Model-facing memory tool and runtime-context memory snapshot.