@skillcap/gdh 0.22.0 → 0.24.0

package/node_modules/@gdh/core/dist/migrations/envelopes/index.d.ts

@@ -0,0 +1,37 @@
+import type { GdhMigrationEnvelope } from "./types.js";
+export declare function isEnvelopeSlug(candidate: unknown): candidate is string;
+/**
+ * Static slug→envelope manifest (D-04).
+ *
+ * Resolution is a `Record` lookup; NO dynamic ES-module loader — that would
+ * add path-traversal surface and lose the static type guarantee that every
+ * shipped envelope is enumerable for tests (the defense-in-depth invariant
+ * in `./index.test.ts` iterates every entry to assert
+ * `key === envelope.envelope_ref` and `isEnvelopeSlug(key)`).
+ *
+ * Phase 73 ships this empty: no Phase 72 registry entry has `envelope_ref`
+ * set (D-25 of Phase 72 reserves `envelope_ref` as the typed escape hatch
+ * for genuinely semantic transforms; the only Phase 72 entry,
+ * `entry_s2c2_to_s2c3_rules_schema`, is mechanical Rule A). The first real
+ * envelope-using migration in a later milestone adds a line to this map by:
+ *
+ *   1. Creating `packages/core/src/migrations/envelopes/<slug>.ts` exporting
+ *      a typed `GdhMigrationEnvelope` whose `envelope_ref === <slug>`.
+ *   2. Adding `<slug>: <imported envelope>` to this object literal.
+ *   3. Adding `envelope_ref: "<slug>"` to the corresponding `GdhMigrationEntry`.
+ *
+ * Threat register reference: T-73-01-03 (inline-literal envelope spoofing).
+ * Mitigation = the manifest is the single registration path; `applyMigrationChain`
+ * (Plan 03) only consumes `resolveEnvelopeBySlug(entry.envelope_ref)` and
+ * never accepts an inline-literal envelope object.
+ */
+export declare const ENVELOPE_REGISTRY: {};
+/**
+ * Resolve a slug to its registered envelope, or null if the slug is malformed
+ * or unknown.
+ *
+ * Two-step gate: shape regex → manifest lookup. Both steps fail closed; no
+ * filesystem access at any step.
+ */
+export declare function resolveEnvelopeBySlug(slug: string): GdhMigrationEnvelope | null;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@gdh/core/dist/migrations/envelopes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/migrations/envelopes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAkBvD,wBAAgB,cAAc,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,MAAM,CAEtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,iBAAiB,IAEqC,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,GACX,oBAAoB,GAAG,IAAI,CAM7B"}

package/node_modules/@gdh/core/dist/migrations/envelopes/index.js

@@ -0,0 +1,60 @@
+/**
+ * Slug shape (D-04): lower-case ASCII letter start, then lower-case ASCII
+ * letters, digits, or underscores. Tight enough that a slug can never escape
+ * the `envelopes/` directory or be used as a path-traversal vector.
+ *
+ * Defense-in-depth: even though `resolveEnvelopeBySlug` is a `Record` lookup
+ * (no `path.join`, no `fs`), the regex shape gate prevents agent-supplied
+ * `envelope_ref` strings from carrying separators or relative segments —
+ * the staleness check and Phase 74 migration-assist skill round-trip the
+ * slug through this regex before any consumer sees it.
+ *
+ * Threat register reference: T-73-01-01 (tampering / information disclosure
+ * via slug-as-path-component).
+ */
+const SLUG_REGEX = /^[a-z][a-z0-9_]*$/;
+export function isEnvelopeSlug(candidate) {
+    return typeof candidate === "string" && SLUG_REGEX.test(candidate);
+}
+/**
+ * Static slug→envelope manifest (D-04).
+ *
+ * Resolution is a `Record` lookup; NO dynamic ES-module loader — that would
+ * add path-traversal surface and lose the static type guarantee that every
+ * shipped envelope is enumerable for tests (the defense-in-depth invariant
+ * in `./index.test.ts` iterates every entry to assert
+ * `key === envelope.envelope_ref` and `isEnvelopeSlug(key)`).
+ *
+ * Phase 73 ships this empty: no Phase 72 registry entry has `envelope_ref`
+ * set (D-25 of Phase 72 reserves `envelope_ref` as the typed escape hatch
+ * for genuinely semantic transforms; the only Phase 72 entry,
+ * `entry_s2c2_to_s2c3_rules_schema`, is mechanical Rule A). The first real
+ * envelope-using migration in a later milestone adds a line to this map by:
+ *
+ *   1. Creating `packages/core/src/migrations/envelopes/<slug>.ts` exporting
+ *      a typed `GdhMigrationEnvelope` whose `envelope_ref === <slug>`.
+ *   2. Adding `<slug>: <imported envelope>` to this object literal.
+ *   3. Adding `envelope_ref: "<slug>"` to the corresponding `GdhMigrationEntry`.
+ *
+ * Threat register reference: T-73-01-03 (inline-literal envelope spoofing).
+ * Mitigation = the manifest is the single registration path; `applyMigrationChain`
+ * (Plan 03) only consumes `resolveEnvelopeBySlug(entry.envelope_ref)` and
+ * never accepts an inline-literal envelope object.
+ */
+export const ENVELOPE_REGISTRY = {
+// [envelope_<slug>.envelope_ref]: envelope_<slug>,  // future
+};
+/**
+ * Resolve a slug to its registered envelope, or null if the slug is malformed
+ * or unknown.
+ *
+ * Two-step gate: shape regex → manifest lookup. Both steps fail closed; no
+ * filesystem access at any step.
+ */
+export function resolveEnvelopeBySlug(slug) {
+    if (!isEnvelopeSlug(slug))
+        return null;
+    return (ENVELOPE_REGISTRY[slug] ??
+        null);
+}
+//# sourceMappingURL=index.js.map

package/node_modules/@gdh/core/dist/migrations/envelopes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/migrations/envelopes/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAEvC,MAAM,UAAU,cAAc,CAAC,SAAkB;IAC/C,OAAO,OAAO,SAAS,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;AAC/B,8DAA8D;CACG,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAY;IAEZ,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACvC,OAAO,CACJ,iBAAoE,CAAC,IAAI,CAAC;QAC3E,IAAI,CACL,CAAC;AACJ,CAAC"}

package/node_modules/@gdh/core/dist/migrations/envelopes/types.d.ts

@@ -0,0 +1,121 @@
+import type { GdhMigrationVersionPair } from "../registry.js";
+/**
+ * Phase 73 migration envelope schema (D-01 / D-02 / D-03 / D-04).
+ *
+ * The envelope is the typed escape hatch for genuinely semantic migrations
+ * that mechanical Rule A (deterministic transform) cannot express. Every
+ * field name is `snake_case` to match the on-disk JSON conventions Phase 72
+ * established for `migration.json` (`recorded_at`, `from_pin`, `to_pin`,
+ * `output_contract`, …); per-field `readonly` mirrors the immutability
+ * pattern at `packages/core/src/migrations/registry.ts:31-56`.
+ *
+ * This file is the single shared schema surface consumed by:
+ *   - `applyMigrationChain` (Plan 03) — emits the envelope when an entry
+ *     declares `envelope_ref`.
+ *   - `gdh migration record-envelope-result` (Plan 05) — validates the
+ *     agent-supplied output_contract against `GdhMigrationEnvelopeOutput`
+ *     via `isEnvelopeOutput` (`./envelope-output-validator.ts`).
+ *   - The static slug→envelope manifest (`./index.ts`).
+ *
+ * D-01 explicitly excludes a clarifying-questions mandate field (it would
+ * conflict with batch `gdh self-update` runs). D-03 explicitly excludes a
+ * per-envelope output_contract extension slot in v1.18 (YAGNI; reintroduce
+ * when envelope variance is real). Per D-04, `envelope_ref` is a slug only
+ * — inline-literal envelope objects on `GdhMigrationEntry.envelope_ref` are
+ * unsupported by construction.
+ */
+/**
+ * Structured mandate (D-01).
+ *
+ * `acceptance_criteria` MUST be enumerated at authoring time so the agent
+ * has a verifiable rubric for its `output_contract` and downstream evidence
+ * recording knows what "done" looks like.
+ */
+export interface GdhMigrationEnvelopeMandate {
+    readonly instruction: string;
+    readonly acceptance_criteria: readonly string[];
+    readonly examples?: readonly string[];
+}
+/**
+ * Tool scope (D-02). Glob patterns mirror gitignore semantics the author
+ * already knows. No deny-list carve-outs in v1.18 (YAGNI).
+ */
+export interface GdhMigrationEnvelopeToolScope {
+    /** Glob patterns the agent MAY read from. */
+    readonly read: readonly string[];
+    /** Glob patterns the agent MAY write to. */
+    readonly write: readonly string[];
+}
+/**
+ * Seed shape for `apply.changes` (D-03). Phase 73 stores the array as
+ * evidence; later phases that ship a real envelope-using migration define
+ * concrete consumers. Keep field names primitive and JSON-safe so the
+ * recorded slot in `migration.json` remains round-trippable through
+ * `JSON.parse`/`JSON.stringify` without per-shape codecs.
+ */
+export type GdhFileChange = {
+    readonly kind: "rewrite";
+    readonly relativePath: string;
+    readonly content: string;
+} | {
+    readonly kind: "delete";
+    readonly relativePath: string;
+};
+/**
+ * Typed discriminated union for the agent's output (D-03).
+ *
+ * Three named outcomes:
+ *   - `apply` — agent produced a concrete change set; `migration.json`
+ *     records `changes` as evidence.
+ *   - `abort` — agent declined; `reason` is recorded for audit trail.
+ *   - `needs_clarification` — agent wants questions answered before applying;
+ *     `questions` are recorded so the operator/next session can resolve them.
+ *
+ * D-03 explicitly excludes a per-envelope extension slot — adding one now
+ * would invite untyped expansion ahead of any real envelope-using migration.
+ */
+export type GdhMigrationEnvelopeOutput = {
+    readonly state: "apply";
+    readonly changes: readonly GdhFileChange[];
+} | {
+    readonly state: "abort";
+    readonly reason: string;
+} | {
+    readonly state: "needs_clarification";
+    readonly questions: readonly string[];
+};
+/**
+ * Migration envelope (D-04).
+ *
+ * Each envelope file under `packages/core/src/migrations/envelopes/<slug>.ts`
+ * exports a single typed `GdhMigrationEnvelope`. `envelope_ref` MUST equal
+ * the file basename and pass `isEnvelopeSlug` (`./index.ts`); the
+ * defense-in-depth invariant test in `./index.test.ts` enforces that
+ * registry key === entry's `envelope_ref` for every shipped envelope.
+ *
+ * `from`/`to` drive the D-10 staleness gate: a previously-recorded envelope
+ * result is valid only when `(envelope_ref, from_pin, to_pin)` all match the
+ * current chain step's bump pair. Pin change → stale → re-emit envelope.
+ *
+ * `fallback_note` reminds the inline-running agent (host that cannot spawn
+ * subagents) that the same mandate, tool_scope, and output_contract apply;
+ * tool scope is discipline-bound rather than enforced by a sandboxed
+ * subagent (per MIGRATION-WORKFLOW.md §4.2).
+ */
+export interface GdhMigrationEnvelope {
+    /** Slug == file basename under envelopes/ (D-04). Lower-case + underscore + digit only. */
+    readonly envelope_ref: string;
+    /** From-pair the envelope is valid for. Used by the D-10 staleness gate. */
+    readonly from: GdhMigrationVersionPair;
+    /** To-pair the envelope is valid for. */
+    readonly to: GdhMigrationVersionPair;
+    readonly mandate: GdhMigrationEnvelopeMandate;
+    readonly tool_scope: GdhMigrationEnvelopeToolScope;
+    /**
+     * Identical mandate prompt and output_contract between subagent and inline
+     * paths (MIGRATION-WORKFLOW.md §4.2). The fallback note reminds the
+     * inline-running agent that tool scope is discipline-bound.
+     */
+    readonly fallback_note: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@gdh/core/dist/migrations/envelopes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/migrations/envelopes/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrF;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,0BAA0B,GAClC;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,GACvE;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAErF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,oBAAoB;IAEnC,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;IACvC,yCAAyC;IACzC,QAAQ,CAAC,EAAE,EAAE,uBAAuB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,6BAA6B,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC"}

package/node_modules/@gdh/core/dist/migrations/envelopes/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/node_modules/@gdh/core/dist/migrations/envelopes/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/migrations/envelopes/types.ts"],"names":[],"mappings":""}

package/node_modules/@gdh/core/dist/migrations/golden-harness.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Per-entry golden fixture harness for migration registry entries.
+ *
+ * Provides `runMigrationGolden(entry, fixturePath)` — reads `<fixturePath>/before/`,
+ * runs the entry's mechanical transform (Phase 72) or future subagent envelope
+ * (Phase 73), and asserts byte-equal match against `<fixturePath>/after/`.
+ *
+ * Phase 71 ships the harness scaffold + one stub golden test that proves the
+ * harness works against a noop transform. Phase 72 authors real registry
+ * entries that consume the harness. Per CONTEXT.md D-15 / D-16: the harness
+ * is a pure utility with no registry dependency — Phase 72's registry imports
+ * the harness, not the other way around.
+ *
+ * Consumers:
+ *   - Phase 71: stub test in golden-harness.test.ts proves the harness works.
+ *   - Phase 72: every migration registry entry's per-entry golden test.
+ *
+ * Per-entry fixture layout (CONTEXT.md D-17):
+ *   tests/fixtures/migration-goldens/<entry-id>/
+ *     before/   <- input file tree, paths relative to the per-entry root
+ *     after/    <- expected output file tree, same path scheme
+ *
+ * Comparison semantics:
+ *   - Default: byte-equal on every file declared in `after/`.
+ *   - Class-2 user-data goldens (Phase 72) may opt into structural
+ *     comparison via an entry-level comparator override (extension point;
+ *     not implemented in Phase 71).
+ */
+export interface GdhMigrationGoldenInputs {
+    readonly files: ReadonlyMap<string, string>;
+}
+export interface GdhMigrationGoldenOutputs {
+    readonly files: ReadonlyMap<string, string>;
+}
+export interface GdhMigrationGoldenEntry {
+    readonly id: string;
+    readonly transform: (input: GdhMigrationGoldenInputs) => Promise<GdhMigrationGoldenOutputs>;
+}
+export declare function runMigrationGolden(entry: GdhMigrationGoldenEntry, fixturePath: string): Promise<void>;
+//# sourceMappingURL=golden-harness.d.ts.map

package/node_modules/@gdh/core/dist/migrations/golden-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"golden-harness.d.ts","sourceRoot":"","sources":["../../src/migrations/golden-harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,CAClB,KAAK,EAAE,wBAAwB,KAC5B,OAAO,CAAC,yBAAyB,CAAC,CAAC;CACzC;AA0BD,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,uBAAuB,EAC9B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/node_modules/@gdh/core/dist/migrations/golden-harness.js

@@ -0,0 +1,71 @@
+/**
+ * Per-entry golden fixture harness for migration registry entries.
+ *
+ * Provides `runMigrationGolden(entry, fixturePath)` — reads `<fixturePath>/before/`,
+ * runs the entry's mechanical transform (Phase 72) or future subagent envelope
+ * (Phase 73), and asserts byte-equal match against `<fixturePath>/after/`.
+ *
+ * Phase 71 ships the harness scaffold + one stub golden test that proves the
+ * harness works against a noop transform. Phase 72 authors real registry
+ * entries that consume the harness. Per CONTEXT.md D-15 / D-16: the harness
+ * is a pure utility with no registry dependency — Phase 72's registry imports
+ * the harness, not the other way around.
+ *
+ * Consumers:
+ *   - Phase 71: stub test in golden-harness.test.ts proves the harness works.
+ *   - Phase 72: every migration registry entry's per-entry golden test.
+ *
+ * Per-entry fixture layout (CONTEXT.md D-17):
+ *   tests/fixtures/migration-goldens/<entry-id>/
+ *     before/   <- input file tree, paths relative to the per-entry root
+ *     after/    <- expected output file tree, same path scheme
+ *
+ * Comparison semantics:
+ *   - Default: byte-equal on every file declared in `after/`.
+ *   - Class-2 user-data goldens (Phase 72) may opt into structural
+ *     comparison via an entry-level comparator override (extension point;
+ *     not implemented in Phase 71).
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+async function readFixtureTree(rootPath) {
+    const files = new Map();
+    async function walk(currentDir, relativePrefix) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(currentDir, entry.name);
+            const entryRelative = relativePrefix === "" ? entry.name : `${relativePrefix}/${entry.name}`;
+            if (entry.isDirectory()) {
+                await walk(entryPath, entryRelative);
+            }
+            else if (entry.isFile()) {
+                files.set(entryRelative, await fs.readFile(entryPath, "utf8"));
+            }
+        }
+    }
+    await walk(rootPath, "");
+    return files;
+}
+export async function runMigrationGolden(entry, fixturePath) {
+    const beforeFiles = await readFixtureTree(path.join(fixturePath, "before"));
+    const expectedAfterFiles = await readFixtureTree(path.join(fixturePath, "after"));
+    const result = await entry.transform({ files: beforeFiles });
+    const actualAfterFiles = result.files;
+    // 1. Every expected file must be present and byte-equal.
+    for (const [relativePath, expectedContent] of expectedAfterFiles) {
+        if (!actualAfterFiles.has(relativePath)) {
+            throw new Error(`Migration golden mismatch: missing expected output file "${relativePath}" for entry "${entry.id}".`);
+        }
+        const actualContent = actualAfterFiles.get(relativePath);
+        if (actualContent !== expectedContent) {
+            throw new Error(`Migration golden mismatch: content differs at "${relativePath}" for entry "${entry.id}".`);
+        }
+    }
+    // 2. Orphan detection — no unexpected output files.
+    for (const relativePath of actualAfterFiles.keys()) {
+        if (!expectedAfterFiles.has(relativePath)) {
+            throw new Error(`Migration golden mismatch: unexpected output file "${relativePath}" produced by entry "${entry.id}".`);
+        }
+    }
+}
+//# sourceMappingURL=golden-harness.js.map

package/node_modules/@gdh/core/dist/migrations/golden-harness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"golden-harness.js","sourceRoot":"","sources":["../../src/migrations/golden-harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAiB7B,KAAK,UAAU,eAAe,CAC5B,QAAgB;IAEhB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IACxC,KAAK,UAAU,IAAI,CACjB,UAAkB,EAClB,cAAsB;QAEtB,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QACtE,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACpD,MAAM,aAAa,GACjB,cAAc,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,cAAc,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACzE,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;gBACxB,MAAM,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACvC,CAAC;iBAAM,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;gBAC1B,KAAK,CAAC,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IACzB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAA8B,EAC9B,WAAmB;IAEnB,MAAM,WAAW,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC5E,MAAM,kBAAkB,GAAG,MAAM,eAAe,CAC9C,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAChC,CAAC;IACF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;IAE7D,MAAM,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC;IAEtC,yDAAyD;IACzD,KAAK,MAAM,CAAC,YAAY,EAAE,eAAe,CAAC,IAAI,kBAAkB,EAAE,CAAC;QACjE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CACb,4DAA4D,YAAY,gBAAgB,KAAK,CAAC,EAAE,IAAI,CACrG,CAAC;QACJ,CAAC;QACD,MAAM,aAAa,GAAG,gBAAgB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACzD,IAAI,aAAa,KAAK,eAAe,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CACb,kDAAkD,YAAY,gBAAgB,KAAK,CAAC,EAAE,IAAI,CAC3F,CAAC;QACJ,CAAC;IACH,CAAC;IAED,oDAAoD;IACpD,KAAK,MAAM,YAAY,IAAI,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC;QACnD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CACb,sDAAsD,YAAY,wBAAwB,KAAK,CAAC,EAAE,IAAI,CACvG,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}