@oscharko-dev/keiko-workflows 0.2.0

package/dist/unit-tests/context.js

@@ -0,0 +1,129 @@
+// Context assembly for the generation call (ADR-0008 D1). Delegates to #5 buildContextPack so the
+// target file, nearby test files, manifests/config, and type definitions are selected, ranked, and
+// excerpted under a byte budget — every excerpt already redacted by #5 at the IO boundary. Pure
+// except for the WorkspaceFs seam threaded into buildContextPack. The `task` hint is a forward-
+// compatible natural-language description of the target for a future embedding ranker; the Wave-1
+// lexical strategy tolerates it.
+import { buildContextPack, DEFAULT_DISCOVERY_OPTIONS, lexicalRetrievalStrategy, SELECTION_REASON_PRIORITY, } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+function toPosix(path) {
+    return path.split("\\").join("/");
+}
+function underDir(path, dir) {
+    const normalized = toPosix(dir);
+    return path === normalized || path.startsWith(`${normalized}/`);
+}
+function basename(path) {
+    const normalized = toPosix(path);
+    const idx = normalized.lastIndexOf("/");
+    return idx === -1 ? normalized : normalized.slice(idx + 1);
+}
+function stem(path) {
+    const base = basename(path);
+    const idx = base.lastIndexOf(".");
+    return idx <= 0 ? base : base.slice(0, idx);
+}
+function testStem(path) {
+    const parts = stem(path).split(".");
+    const marker = parts.findIndex((part) => part === "test" || part === "spec");
+    return marker === -1 ? parts.join(".") : parts.slice(0, marker).join(".");
+}
+function targetPaths(target) {
+    if (target.kind === "file") {
+        return [toPosix(target.filePath)];
+    }
+    if (target.kind === "changedFiles") {
+        return target.filePaths.map(toPosix);
+    }
+    return [];
+}
+function moduleDir(target) {
+    return target.kind === "module" ? toPosix(target.moduleDir) : undefined;
+}
+function isRequestedTarget(path, input) {
+    const module = moduleDir(input.target);
+    return (targetPaths(input.target).includes(path) || (module !== undefined && underDir(path, module)));
+}
+function isTestCandidate(path, workspace, selectionReason) {
+    return (selectionReason === "test" ||
+        workspace.testDirs.some((testDir) => underDir(path, testDir)) ||
+        stem(path)
+            .split(".")
+            .some((part) => part === "test" || part === "spec"));
+}
+function isNearbyTest(path, workspace, input, selectionReason) {
+    if (!isTestCandidate(path, workspace, selectionReason)) {
+        return false;
+    }
+    const targets = targetPaths(input.target);
+    if (targets.length === 0) {
+        const module = moduleDir(input.target);
+        return module !== undefined && path.includes(basename(module));
+    }
+    const candidateStem = testStem(path);
+    return targets.some((target) => candidateStem === stem(target));
+}
+function priorityIndex(reason) {
+    return SELECTION_REASON_PRIORITY.indexOf(reason);
+}
+function issue8Priority(ranked, workspace, input) {
+    const path = toPosix(ranked.file.relativePath);
+    if (isRequestedTarget(path, input)) {
+        return 0;
+    }
+    if (isNearbyTest(path, workspace, input, ranked.selectionReason)) {
+        return 1;
+    }
+    return 2;
+}
+function isSupportContext(ranked) {
+    return ranked.selectionReason === "manifest" || ranked.selectionReason === "config";
+}
+function focusedContext(ranked, workspace, input) {
+    const focused = ranked.filter((item) => issue8Priority(item, workspace, input) < 2 || isSupportContext(item));
+    return focused.length === 0 ? ranked : focused;
+}
+function createUnitTestRetrievalStrategy(workspace, input) {
+    return {
+        rank: (files, task) => {
+            const ranked = focusedContext(lexicalRetrievalStrategy.rank(files, task), workspace, input);
+            return [...ranked].sort((a, b) => {
+                const byIssue8 = issue8Priority(a, workspace, input) - issue8Priority(b, workspace, input);
+                if (byIssue8 !== 0) {
+                    return byIssue8;
+                }
+                const byReason = priorityIndex(a.selectionReason) - priorityIndex(b.selectionReason);
+                if (byReason !== 0) {
+                    return byReason;
+                }
+                return a.file.relativePath.localeCompare(b.file.relativePath);
+            });
+        },
+    };
+}
+function taskHint(target) {
+    if (target.kind === "file") {
+        return target.targetFunction === undefined
+            ? `unit tests for ${target.filePath}`
+            : `unit tests for ${target.targetFunction} in ${target.filePath}`;
+    }
+    if (target.kind === "module") {
+        return `unit tests for module ${target.moduleDir}`;
+    }
+    return `unit tests for ${target.filePaths.join(", ")}`;
+}
+export function buildTestGenContext(workspace, input, limits, deps = {}) {
+    const request = {
+        task: taskHint(input.target),
+        budgetBytes: limits.contextBudgetBytes,
+        maxBytesPerFile: limits.maxBytesPerFile,
+        discovery: DEFAULT_DISCOVERY_OPTIONS,
+    };
+    // buildContextPack defaults to the lexical strategy, but ContextPackDeps requires the field; pass
+    // the #5 barrel default explicitly so we hand a complete deps object without reaching past #5.
+    const packDeps = {
+        fs: deps.fs ?? nodeWorkspaceFs,
+        strategy: createUnitTestRetrievalStrategy(workspace, input),
+    };
+    return buildContextPack(workspace, request, packDeps);
+}

package/dist/unit-tests/conventions.d.ts

@@ -0,0 +1,5 @@
+import type { ContextPack, WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+import type { TestConventions } from "./types.js";
+export declare function isTestPath(workspace: WorkspaceInfo, relPath: string): boolean;
+export declare function detectConventions(workspace: WorkspaceInfo, pack: ContextPack): TestConventions;
+//# sourceMappingURL=conventions.d.ts.map

package/dist/unit-tests/conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../src/unit-tests/conventions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,KAAK,EAAmB,eAAe,EAAE,MAAM,YAAY,CAAC;AA0CnE,wBAAgB,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAM7E;AA4CD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,GAAG,eAAe,CAO9F"}

package/dist/unit-tests/conventions.js

@@ -0,0 +1,87 @@
+// Convention detection (ADR-0008 D7) and the production-code guard predicate (D6). Pure except
+// for the WorkspaceInfo/ContextPack values handed in (no IO, no clock, no RNG). ALL path and
+// naming predicates use plain string ops (split('.'), startsWith, equality) — zero regex — so
+// there is no ReDoS surface (CodeQL js/polynomial-redos, steering note F).
+import { basename, dirname, extname } from "node:path";
+const MAX_ASSERTION_SAMPLES = 2;
+const TEST_SEGMENTS = ["test", "spec"];
+// Normalises a path to forward slashes so dir/segment checks are platform-independent.
+function toPosix(path) {
+    return path.split("\\").join("/");
+}
+// True when the basename (without its final extension) contains "test" or "spec" as a
+// dot-separated segment. `foo.test.ts` -> ["foo","test"] -> pass; `testUtils.ts` ->
+// ["testUtils"] -> FAIL (prefix, not a segment); `foo.spec.utils.ts` -> ["foo","spec","utils"] -> pass.
+function basenameMarksTest(path) {
+    const ext = extname(path);
+    const stem = basename(path, ext);
+    const segments = stem.split(".");
+    return segments.some((segment) => TEST_SEGMENTS.includes(segment));
+}
+// True when the path's directory equals or sits under one of the configured testDirs.
+function underTestDir(testDirs, posixPath) {
+    const dir = dirname(posixPath);
+    return testDirs.some((rawTestDir) => {
+        const testDir = toPosix(rawTestDir);
+        return dir === testDir || dir.startsWith(`${testDir}/`) || posixPath.startsWith(`${testDir}/`);
+    });
+}
+// A path containing a `..` segment or an absolute leading slash is traversal: it can resolve to a
+// production file OUTSIDE the apparent test directory. `tests/../src/auth.ts` lexically starts with
+// `tests/`, but #6 resolveWithinWorkspace collapses it to the in-workspace `src/auth.ts` and writes
+// THAT. A legitimately generated test path is always a clean workspace-relative path, so we reject
+// traversal fail-closed before any test/testDir check (security fix: D6 bypass via path traversal).
+function isTraversal(posixPath) {
+    return posixPath.startsWith("/") || posixPath.split("/").includes("..");
+}
+// The production-code guard predicate (D6): a path passes if its basename marks it a test file OR
+// it lies under a detected testDir. Used to reject any patch that touches a non-test path before
+// renderDryRun/applyPatch — the second barrier against prompt-injected source modification. Any
+// traversal/absolute path is rejected outright so the guarded path matches the path #6 would write.
+export function isTestPath(workspace, relPath) {
+    const posixPath = toPosix(relPath);
+    if (isTraversal(posixPath)) {
+        return false;
+    }
+    return basenameMarksTest(posixPath) || underTestDir(workspace.testDirs, posixPath);
+}
+// The set of test excerpts already selected by #5 (redacted, bounded), capped to MAX_ASSERTION_SAMPLES.
+function sampleAssertionStyle(pack) {
+    return pack.selected
+        .filter((entry) => entry.selectionReason === "test")
+        .slice(0, MAX_ASSERTION_SAMPLES)
+        .map((entry) => entry.excerpt);
+}
+// Whether any selected pack entry is a sibling test (a test file whose directory matches a
+// non-test source path's directory). We approximate "sibling" as a test-marked path NOT under a
+// configured testDir, and "mirrored" as a test-marked path under a testDir.
+function hasSiblingTest(workspace, pack) {
+    return pack.selected.some((entry) => basenameMarksTest(toPosix(entry.path)) &&
+        !underTestDir(workspace.testDirs, toPosix(entry.path)));
+}
+function hasMirroredTest(workspace, pack) {
+    return pack.selected.some((entry) => basenameMarksTest(toPosix(entry.path)) &&
+        underTestDir(workspace.testDirs, toPosix(entry.path)));
+}
+function deriveNamingStyle(workspace, pack) {
+    if (hasSiblingTest(workspace, pack)) {
+        return "sibling";
+    }
+    if (workspace.testDirs.length > 0 && hasMirroredTest(workspace, pack)) {
+        return "mirrored";
+    }
+    // testDirs present but no observed test sample: default to mirrored (the conventional placement
+    // under tests/). Only when there is neither a testDir nor a sample is the style unknown.
+    if (workspace.testDirs.length > 0) {
+        return "mirrored";
+    }
+    return "unknown";
+}
+export function detectConventions(workspace, pack) {
+    return {
+        framework: workspace.testFramework,
+        testDirs: workspace.testDirs,
+        fileNamingStyle: deriveNamingStyle(workspace, pack),
+        assertionStyleSamples: sampleAssertionStyle(pack),
+    };
+}

package/dist/unit-tests/descriptor.d.ts

@@ -0,0 +1,5 @@
+import { type WorkflowLimits } from "./types.js";
+import type { WorkflowDescriptor } from "../descriptor.js";
+export type { WorkflowDescriptor, WorkflowInputSpec } from "../descriptor.js";
+export declare const UNIT_TEST_WORKFLOW_DESCRIPTOR: WorkflowDescriptor<WorkflowLimits>;
+//# sourceMappingURL=descriptor.d.ts.map

package/dist/unit-tests/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../src/unit-tests/descriptor.ts"],"names":[],"mappings":"AAKA,OAAO,EAA2B,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE9E,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,cAAc,CAuCnE,CAAC"}

package/dist/unit-tests/descriptor.js

@@ -0,0 +1,43 @@
+// The static UI workflow descriptor (ADR-0008 D10). Issue #13 reads this to render the workflow
+// UI without knowing the implementation. Frozen and JSON-serializable. The descriptor interfaces
+// are the shared base (ADR-0009 D12) — re-exported here so #8's existing import surface (the
+// unit-tests barrel) is unchanged; both workflows depend on the base and neither on the other.
+import { DEFAULT_WORKFLOW_LIMITS } from "./types.js";
+export const UNIT_TEST_WORKFLOW_DESCRIPTOR = {
+    workflowId: "unit-test-generation",
+    name: "Unit Test Generation",
+    description: "Generates a reviewable unit-test patch for a target TypeScript file, function, or module. " +
+        "Detects the project's test framework and naming conventions. Dry-run by default; " +
+        "pass apply:true to write the tests and run verification.",
+    inputs: [
+        {
+            name: "target",
+            type: "object",
+            required: true,
+            description: "Target: { kind: 'file', filePath } | { kind: 'module', moduleDir } | { kind: 'changedFiles', filePaths }",
+        },
+        {
+            name: "apply",
+            type: "boolean",
+            required: false,
+            description: "Write tests to disk and run verification",
+            defaultValue: false,
+        },
+        {
+            name: "modelId",
+            type: "string",
+            required: true,
+            description: "Model ID registered in gateway config",
+        },
+        {
+            name: "limits",
+            type: "object",
+            required: false,
+            description: "Partial<WorkflowLimits> overrides",
+        },
+    ],
+    defaultLimits: DEFAULT_WORKFLOW_LIMITS,
+    modelSelectionOptions: { arbitrary: true, preferredCostClass: "medium" },
+    supportsDryRun: true,
+    supportsApply: true,
+};

package/dist/unit-tests/emit.d.ts

@@ -0,0 +1,13 @@
+import type { UnitTestTarget } from "./types.js";
+import type { WorkflowEvent, WorkflowEventSink } from "./events.js";
+export declare function computeFingerprint(target: UnitTestTarget, modelId: string): string;
+type EnvelopeFields = "schemaVersion" | "runId" | "fingerprint" | "seq" | "ts";
+export type WorkflowEventBody = {
+    [E in WorkflowEvent as E["type"]]: Omit<E, EnvelopeFields>;
+}[WorkflowEvent["type"]];
+export interface EventEmitter {
+    readonly emit: (body: WorkflowEventBody) => void;
+}
+export declare function createEventEmitter(sink: WorkflowEventSink, runId: string, fingerprint: string, now: () => number): EventEmitter;
+export {};
+//# sourceMappingURL=emit.d.ts.map

package/dist/unit-tests/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/unit-tests/emit.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAMlF;AAID,KAAK,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,aAAa,GAAG,KAAK,GAAG,IAAI,CAAC;AAC/E,MAAM,MAAM,iBAAiB,GAAG;KAC7B,CAAC,IAAI,aAAa,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,cAAc,CAAC;CAC3D,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,MAAM,MAAM,GAChB,YAAY,CAkBd"}

package/dist/unit-tests/emit.js

@@ -0,0 +1,35 @@
+// Event emission helper for the workflow (ADR-0008 D4). Owns the monotonic seq counter and stamps
+// every event with the shared envelope ({ schemaVersion, runId, fingerprint, seq, ts }). The
+// fingerprint is SHA-256(workflowId + canonical(target) + modelId) truncated to 16 hex chars — the
+// same shape as the harness fingerprinter — reusing `canonicalise` from the harness barrel so two
+// structurally equal targets fingerprint identically regardless of key order. Sensitive fields are
+// redacted by the CALLER before handing the event here (this helper does not inspect payloads).
+import { createHash } from "node:crypto";
+import { canonicalise } from "@oscharko-dev/keiko-harness";
+const FINGERPRINT_HEX_CHARS = 16;
+export function computeFingerprint(target, modelId) {
+    const canonical = canonicalise({ workflowId: "unit-test-generation", target, modelId });
+    return createHash("sha256")
+        .update(canonical, "utf8")
+        .digest("hex")
+        .slice(0, FINGERPRINT_HEX_CHARS);
+}
+export function createEventEmitter(sink, runId, fingerprint, now) {
+    let seq = 0;
+    return {
+        emit: (body) => {
+            seq += 1;
+            // The body is a complete discriminated-union member minus the envelope; re-attaching the
+            // envelope yields a valid WorkflowEvent. The cast is over the union, not a widening to any.
+            const event = {
+                schemaVersion: "1",
+                runId,
+                fingerprint,
+                seq,
+                ts: now(),
+                ...body,
+            };
+            sink.emit(event);
+        },
+    };
+}

package/dist/unit-tests/events.d.ts

@@ -0,0 +1,2 @@
+export type { WorkflowStartedEvent, ConventionsDetectedEvent, ContextSelectedEvent, ModelCallStartedEvent, ModelCallCompletedEvent, PatchValidatedEvent, PatchAppliedEvent, VerificationResultEvent, WorkflowCompletedEvent, WorkflowFailedEvent, WorkflowEvent, WorkflowEventSink, } from "@oscharko-dev/keiko-contracts/unit-test-events";
+//# sourceMappingURL=events.d.ts.map

package/dist/unit-tests/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/unit-tests/events.ts"],"names":[],"mappings":"AAMA,YAAY,EACV,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,GAClB,MAAM,gDAAgD,CAAC"}

package/dist/unit-tests/events.js

@@ -0,0 +1,6 @@
+// Re-export shim: the unit-test workflow event union and every member interface live in
+// @oscharko-dev/keiko-contracts (issue #158). The contracts BARREL exposes only WorkflowEvent +
+// WorkflowEventSink because several member names collide with HarnessEvent members by structural
+// convention (ADR-0008 D4); the contracts subpath `unit-test-events` carries the full member set
+// so internal consumers can keep importing concrete shapes from "./events.js" unchanged.
+export {};

package/dist/unit-tests/frontend.d.ts

@@ -0,0 +1,42 @@
+import type { TestFramework, WorkspaceInfo } from "@oscharko-dev/keiko-workspace";
+export type ComponentFramework = "react" | "none";
+export interface FrontendTestStack {
+    readonly componentFramework: ComponentFramework;
+    readonly hasReactTestingLibrary: boolean;
+    readonly hasUserEvent: boolean;
+    readonly hasJestDom: boolean;
+    readonly hasAccessibilityMatchers: boolean;
+    readonly hasDomEnvironment: boolean;
+    readonly hasPlaywright: boolean;
+}
+export declare const EMPTY_FRONTEND_TEST_STACK: FrontendTestStack;
+export type TestStyle = "unit" | "component" | "interaction" | "accessibility-smoke" | "browser-smoke" | "unsupported";
+export declare const TEST_STYLES: readonly TestStyle[];
+export type TestVerification = "vitest" | "jest" | "mocha" | "playwright" | "none";
+export interface TestStrategy {
+    readonly style: TestStyle;
+    readonly reason: string;
+    readonly verification: TestVerification;
+}
+export declare function manifestDependencyNames(manifestJson: string): ReadonlySet<string>;
+export interface FrontendStackSignals {
+    readonly hasPlaywrightConfig: boolean;
+}
+export declare function detectFrontendStackFromDependencies(names: ReadonlySet<string>, signals: FrontendStackSignals): FrontendTestStack;
+export interface ManifestReaderFs {
+    readonly exists: (absolutePath: string) => boolean;
+    readonly readFileUtf8: (absolutePath: string) => string;
+}
+export declare function detectFrontendStack(workspace: WorkspaceInfo, fs: ManifestReaderFs, anchorRelPath?: string): FrontendTestStack;
+export declare function isReactComponentPath(path: string): boolean;
+export declare function looksLikeReactComponentSource(source: string | undefined): boolean;
+export declare function isPlaywrightEntryPath(path: string): boolean;
+export declare function isPlaywrightSmokeAppropriate(path: string, stack: FrontendTestStack): boolean;
+export interface StrategyInput {
+    readonly targetPath: string;
+    readonly targetSource?: string | undefined;
+    readonly framework: TestFramework;
+    readonly stack: FrontendTestStack;
+}
+export declare function selectTestStrategy(input: StrategyInput): TestStrategy;
+//# sourceMappingURL=frontend.d.ts.map

package/dist/unit-tests/frontend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend.d.ts","sourceRoot":"","sources":["../../src/unit-tests/frontend.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAIlF,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,MAAM,CAAC;AAIlD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAEhD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IAEzC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAE/B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B,QAAQ,CAAC,wBAAwB,EAAE,OAAO,CAAC;IAE3C,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IAEpC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED,eAAO,MAAM,yBAAyB,EAAE,iBAQ9B,CAAC;AAIX,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,WAAW,GACX,aAAa,GACb,qBAAqB,GACrB,eAAe,GACf,aAAa,CAAC;AAElB,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAOlC,CAAC;AAKX,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,MAAM,CAAC;AAEnF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAG1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;CACzC;AAiBD,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAoBjF;AAsBD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAID,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,OAAO,EAAE,oBAAoB,GAC5B,iBAAiB,CAUnB;AAMD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;IACnD,QAAQ,CAAC,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;CACzD;AAqDD,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,aAAa,EACxB,EAAE,EAAE,gBAAgB,EACpB,aAAa,CAAC,EAAE,MAAM,GACrB,iBAAiB,CAYnB;AAqBD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAKD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAYjF;AAmBD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAU3D;AAMD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAE5F;AAID,MAAM,WAAW,aAAa;IAE5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE3C,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAsDD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAerE"}