forge-dev-framework 1.0.1

package/dist/git/wipe-protocol.d.ts

@@ -0,0 +1,281 @@
+/**
+ * The Wipe Protocol - Context Hygiene for FORGE
+ *
+ * Treats agent context as ephemeral, git as persistent.
+ *
+ * Lifecycle:
+ * 1. Hydrate — Agent starts, reads CLAUDE.md + STATE.json + assigned task + contracts
+ * 2. Execute — Agent writes code, runs tests within its domain
+ * 3. Commit — Atomic git commit linked to task ID
+ * 4. Terminate — Session ends, context wiped
+ * 5. Reincarnate — Next task starts with fresh context, reads NEW git state
+ */
+import { z } from "zod";
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    ownerRole: z.ZodString;
+    status: z.ZodEnum<["pending", "in_progress", "completed", "blocked"]>;
+    deps: z.ZodArray<z.ZodString, "many">;
+    allowedPaths: z.ZodArray<z.ZodString, "many">;
+    acceptance: z.ZodArray<z.ZodString, "many">;
+    verify: z.ZodArray<z.ZodString, "many">;
+    commit: z.ZodNullable<z.ZodString>;
+    requests: z.ZodArray<z.ZodString, "many">;
+    priority: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "in_progress" | "completed" | "blocked";
+    allowedPaths: string[];
+    commit: string | null;
+    id: string;
+    title: string;
+    ownerRole: string;
+    deps: string[];
+    acceptance: string[];
+    verify: string[];
+    requests: string[];
+    priority: number;
+}, {
+    status: "pending" | "in_progress" | "completed" | "blocked";
+    allowedPaths: string[];
+    commit: string | null;
+    id: string;
+    title: string;
+    ownerRole: string;
+    deps: string[];
+    acceptance: string[];
+    verify: string[];
+    requests: string[];
+    priority: number;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const StateSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodString;
+        currentMilestone: z.ZodString;
+        currentPhase: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        name: string;
+        currentMilestone: string;
+        currentPhase: number;
+    }, {
+        status: string;
+        name: string;
+        currentMilestone: string;
+        currentPhase: number;
+    }>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        ownerRole: z.ZodString;
+        status: z.ZodEnum<["pending", "in_progress", "completed", "blocked"]>;
+        deps: z.ZodArray<z.ZodString, "many">;
+        allowedPaths: z.ZodArray<z.ZodString, "many">;
+        acceptance: z.ZodArray<z.ZodString, "many">;
+        verify: z.ZodArray<z.ZodString, "many">;
+        commit: z.ZodNullable<z.ZodString>;
+        requests: z.ZodArray<z.ZodString, "many">;
+        priority: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "in_progress" | "completed" | "blocked";
+        allowedPaths: string[];
+        commit: string | null;
+        id: string;
+        title: string;
+        ownerRole: string;
+        deps: string[];
+        acceptance: string[];
+        verify: string[];
+        requests: string[];
+        priority: number;
+    }, {
+        status: "pending" | "in_progress" | "completed" | "blocked";
+        allowedPaths: string[];
+        commit: string | null;
+        id: string;
+        title: string;
+        ownerRole: string;
+        deps: string[];
+        acceptance: string[];
+        verify: string[];
+        requests: string[];
+        priority: number;
+    }>, "many">;
+    contracts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        version: z.ZodString;
+        publishedBy: z.ZodString;
+        consumers: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        version: string;
+        publishedBy: string;
+        consumers: string[];
+    }, {
+        path: string;
+        id: string;
+        version: string;
+        publishedBy: string;
+        consumers: string[];
+    }>, "many">;
+    eventsPointer: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    project: {
+        status: string;
+        name: string;
+        currentMilestone: string;
+        currentPhase: number;
+    };
+    tasks: {
+        status: "pending" | "in_progress" | "completed" | "blocked";
+        allowedPaths: string[];
+        commit: string | null;
+        id: string;
+        title: string;
+        ownerRole: string;
+        deps: string[];
+        acceptance: string[];
+        verify: string[];
+        requests: string[];
+        priority: number;
+    }[];
+    contracts: {
+        path: string;
+        id: string;
+        version: string;
+        publishedBy: string;
+        consumers: string[];
+    }[];
+    eventsPointer: string;
+}, {
+    project: {
+        status: string;
+        name: string;
+        currentMilestone: string;
+        currentPhase: number;
+    };
+    tasks: {
+        status: "pending" | "in_progress" | "completed" | "blocked";
+        allowedPaths: string[];
+        commit: string | null;
+        id: string;
+        title: string;
+        ownerRole: string;
+        deps: string[];
+        acceptance: string[];
+        verify: string[];
+        requests: string[];
+        priority: number;
+    }[];
+    contracts: {
+        path: string;
+        id: string;
+        version: string;
+        publishedBy: string;
+        consumers: string[];
+    }[];
+    eventsPointer: string;
+}>;
+export type State = z.infer<typeof StateSchema>;
+export interface HydrateContext {
+    claudeRules: string;
+    state: State;
+    task: Task;
+    contracts: Map<string, string>;
+}
+/**
+ * Phase 1: Hydrate
+ *
+ * Agent starts. Reads all necessary context from the repository.
+ * This is the ONLY state the agent receives - no conversation history.
+ *
+ * @param taskId - The task ID to hydrate for
+ * @param basePath - Root of the FORGE project
+ * @returns Hydration context with all necessary artifacts
+ */
+export declare function hydrate(taskId: string, basePath?: string): Promise<HydrateContext>;
+/**
+ * Phase 2: Execute
+ *
+ * Agent writes code, runs tests within its domain.
+ * This is where the actual work happens.
+ *
+ * Note: This function is a placeholder - the actual execution
+ * is done by the agent teammate. We just provide the isolation
+ * context (worktree) and validation (allowedPaths).
+ *
+ * @param taskId - The task ID being executed
+ * @param basePath - Root of the FORGE project
+ * @returns Path to the worktree for execution
+ */
+export declare function execute(taskId: string, basePath?: string): Promise<string>;
+/**
+ * Validate that files are within allowed paths for a task.
+ *
+ * Enforces the CODEOWNERS boundary - agents can only write
+ * within their assigned domain.
+ *
+ * @param files - Files to validate
+ * @param allowedPaths - Allowed path patterns
+ * @throws Error if any file is out of scope
+ */
+export declare function validateScope(files: string[], allowedPaths: string[]): void;
+/**
+ * Phase 3: Commit
+ *
+ * Atomic git commit linked to task ID.
+ * Every task MUST result in exactly one commit.
+ *
+ * Format: type(scope): description
+ * Example: feat(api-003): implement session authentication
+ *
+ * @param taskId - The task ID
+ * @param message - Commit message (will be formatted)
+ * @param basePath - Root of the FORGE project
+ * @returns The commit hash
+ */
+export declare function commitTask(taskId: string, message: string, basePath?: string): Promise<string>;
+/**
+ * Phase 4: Terminate
+ *
+ * Session ends. Context is wiped clean.
+ * The agent's conversation history is discarded.
+ *
+ * Note: In Agent Teams, this happens naturally when the agent
+ * exits. We just need to ensure the worktree is cleaned up.
+ *
+ * @param taskId - The task ID
+ * @param keepWorktree - Whether to keep the worktree (for debugging)
+ */
+export declare function terminate(taskId: string, keepWorktree?: boolean): Promise<void>;
+/**
+ * Phase 5: Reincarnate
+ *
+ * Next task starts with fresh context, reading the NEW git state.
+ *
+ * This happens naturally when a new agent spawns - they start
+ * with a fresh context window and hydrate() to read current state.
+ *
+ * @param nextTaskId - The next task ID to work on
+ * @param basePath - Root of the FORGE project
+ * @returns Hydration context for the next task
+ */
+export declare function reincarnate(nextTaskId: string, basePath?: string): Promise<HydrateContext>;
+/**
+ * Execute the full Wipe Protocol lifecycle for a task.
+ *
+ * This is the main entry point that orchestrates all phases.
+ * Note that phases 2 (execute) and 4 (terminate) happen
+ * externally - this just sets up and tears down.
+ *
+ * @param taskId - The task ID to execute
+ * @param workCallback - Async function that does the actual work
+ * @param basePath - Root of the FORGE project
+ * @returns Commit hash from the completed task
+ */
+export declare function runWipeProtocol(taskId: string, workCallback: (worktreePath: string) => Promise<string>, basePath?: string): Promise<string>;
+//# sourceMappingURL=wipe-protocol.d.ts.map

package/dist/git/wipe-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wipe-protocol.d.ts","sourceRoot":"","sources":["../../src/git/wipe-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYrB,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBtB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAoC,GAAG,OAAO,CAAC,cAAc,CAAC,CAoCrH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAoC,GAAG,OAAO,CAAC,MAAM,CAAC,CAY7G;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI,CAgB3E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAoC,GAC7C,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,MAAoC,GAC7C,OAAO,CAAC,cAAc,CAAC,CAGzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EACvD,QAAQ,GAAE,MAAoC,GAC7C,OAAO,CAAC,MAAM,CAAC,CAuBjB"}

package/dist/git/wipe-protocol.js

@@ -0,0 +1,237 @@
+/**
+ * The Wipe Protocol - Context Hygiene for FORGE
+ *
+ * Treats agent context as ephemeral, git as persistent.
+ *
+ * Lifecycle:
+ * 1. Hydrate — Agent starts, reads CLAUDE.md + STATE.json + assigned task + contracts
+ * 2. Execute — Agent writes code, runs tests within its domain
+ * 3. Commit — Atomic git commit linked to task ID
+ * 4. Terminate — Session ends, context wiped
+ * 5. Reincarnate — Next task starts with fresh context, reads NEW git state
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { createWorktree, getWorktree, cleanupWorktree } from "./worktree.js";
+// Schemas for FORGE artifacts
+export const TaskSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    ownerRole: z.string(),
+    status: z.enum(["pending", "in_progress", "completed", "blocked"]),
+    deps: z.array(z.string()),
+    allowedPaths: z.array(z.string()),
+    acceptance: z.array(z.string()),
+    verify: z.array(z.string()),
+    commit: z.string().nullable(),
+    requests: z.array(z.string()),
+    priority: z.number(),
+});
+export const StateSchema = z.object({
+    project: z.object({
+        name: z.string(),
+        status: z.string(),
+        currentMilestone: z.string(),
+        currentPhase: z.number(),
+    }),
+    tasks: z.array(TaskSchema),
+    contracts: z.array(z.object({
+        id: z.string(),
+        path: z.string(),
+        version: z.string(),
+        publishedBy: z.string(),
+        consumers: z.array(z.string()),
+    })),
+    eventsPointer: z.string(),
+});
+/**
+ * Phase 1: Hydrate
+ *
+ * Agent starts. Reads all necessary context from the repository.
+ * This is the ONLY state the agent receives - no conversation history.
+ *
+ * @param taskId - The task ID to hydrate for
+ * @param basePath - Root of the FORGE project
+ * @returns Hydration context with all necessary artifacts
+ */
+export async function hydrate(taskId, basePath = "/home/parz/projects/forge") {
+    // Read STATE.json to get task information
+    const statePath = join(basePath, "state", "STATE.json");
+    const stateRaw = await readFile(statePath, "utf-8");
+    const state = StateSchema.parse(JSON.parse(stateRaw));
+    // Find the assigned task
+    const task = state.tasks.find((t) => t.id === taskId);
+    if (!task) {
+        throw new Error(`Task ${taskId} not found in STATE.json`);
+    }
+    // Read CLAUDE.md - the project constitution
+    const claudePath = join(basePath, "CLAUDE.md");
+    let claudeRules = "";
+    try {
+        claudeRules = await readFile(claudePath, "utf-8");
+    }
+    catch {
+        // CLAUDE.md might not exist yet in early phases
+        claudeRules = "# CLAUDE.md\n\nNo project rules defined yet.";
+    }
+    // Read contract files referenced by the task
+    const contracts = new Map();
+    const contractsPath = join(basePath, "contracts");
+    // If task references specific contracts, load them
+    // This would be populated from task.contracts field
+    // For now, we just check if contracts directory exists
+    return {
+        claudeRules,
+        state,
+        task,
+        contracts,
+    };
+}
+/**
+ * Phase 2: Execute
+ *
+ * Agent writes code, runs tests within its domain.
+ * This is where the actual work happens.
+ *
+ * Note: This function is a placeholder - the actual execution
+ * is done by the agent teammate. We just provide the isolation
+ * context (worktree) and validation (allowedPaths).
+ *
+ * @param taskId - The task ID being executed
+ * @param basePath - Root of the FORGE project
+ * @returns Path to the worktree for execution
+ */
+export async function execute(taskId, basePath = "/home/parz/projects/forge") {
+    // Check if worktree already exists (resuming from pause)
+    const existing = await getWorktree(taskId);
+    if (existing) {
+        return existing.path;
+    }
+    // Create new worktree for this task
+    const worktreePath = await createWorktree({ taskId });
+    // Return absolute path to worktree
+    return join(basePath, worktreePath);
+}
+/**
+ * Validate that files are within allowed paths for a task.
+ *
+ * Enforces the CODEOWNERS boundary - agents can only write
+ * within their assigned domain.
+ *
+ * @param files - Files to validate
+ * @param allowedPaths - Allowed path patterns
+ * @throws Error if any file is out of scope
+ */
+export function validateScope(files, allowedPaths) {
+    for (const file of files) {
+        const isAllowed = allowedPaths.some((pattern) => {
+            // Simple glob matching - converts gitignore-style patterns to regex
+            const regexPattern = pattern
+                .replace(/\*\*/g, ".*")
+                .replace(/\*/g, "[^/]*")
+                .replace(/\?/g, "[^/]");
+            const regex = new RegExp(`^${regexPattern}`);
+            return regex.test(file);
+        });
+        if (!isAllowed) {
+            throw new Error(`File ${file} is outside allowed paths: ${allowedPaths.join(", ")}`);
+        }
+    }
+}
+/**
+ * Phase 3: Commit
+ *
+ * Atomic git commit linked to task ID.
+ * Every task MUST result in exactly one commit.
+ *
+ * Format: type(scope): description
+ * Example: feat(api-003): implement session authentication
+ *
+ * @param taskId - The task ID
+ * @param message - Commit message (will be formatted)
+ * @param basePath - Root of the FORGE project
+ * @returns The commit hash
+ */
+export async function commitTask(taskId, message, basePath = "/home/parz/projects/forge") {
+    const { execa } = await import("execa");
+    // Format the commit message to include task ID
+    const formattedMessage = message.includes(taskId)
+        ? message
+        : `feat(${taskId}): ${message}`;
+    // Stage all changes in the worktree
+    await execa("git", ["add", "-A"], { cwd: join(basePath, `.worktrees/${taskId}`) });
+    // Commit with formatted message
+    const { stdout } = await execa("git", ["commit", "-m", formattedMessage], {
+        cwd: join(basePath, `.worktrees/${taskId}`),
+    });
+    // Extract commit hash from output
+    const commitHash = stdout.match(/\[([a-f0-9]+)\]/)?.[1] || "";
+    return commitHash;
+}
+/**
+ * Phase 4: Terminate
+ *
+ * Session ends. Context is wiped clean.
+ * The agent's conversation history is discarded.
+ *
+ * Note: In Agent Teams, this happens naturally when the agent
+ * exits. We just need to ensure the worktree is cleaned up.
+ *
+ * @param taskId - The task ID
+ * @param keepWorktree - Whether to keep the worktree (for debugging)
+ */
+export async function terminate(taskId, keepWorktree = false) {
+    if (!keepWorktree) {
+        await cleanupWorktree(taskId);
+    }
+}
+/**
+ * Phase 5: Reincarnate
+ *
+ * Next task starts with fresh context, reading the NEW git state.
+ *
+ * This happens naturally when a new agent spawns - they start
+ * with a fresh context window and hydrate() to read current state.
+ *
+ * @param nextTaskId - The next task ID to work on
+ * @param basePath - Root of the FORGE project
+ * @returns Hydration context for the next task
+ */
+export async function reincarnate(nextTaskId, basePath = "/home/parz/projects/forge") {
+    // Reincarnation is just hydration with fresh context
+    return hydrate(nextTaskId, basePath);
+}
+/**
+ * Execute the full Wipe Protocol lifecycle for a task.
+ *
+ * This is the main entry point that orchestrates all phases.
+ * Note that phases 2 (execute) and 4 (terminate) happen
+ * externally - this just sets up and tears down.
+ *
+ * @param taskId - The task ID to execute
+ * @param workCallback - Async function that does the actual work
+ * @param basePath - Root of the FORGE project
+ * @returns Commit hash from the completed task
+ */
+export async function runWipeProtocol(taskId, workCallback, basePath = "/home/parz/projects/forge") {
+    // Phase 1: Hydrate
+    const context = await hydrate(taskId, basePath);
+    // Phase 2: Execute (setup worktree, call the worker)
+    const worktreePath = await execute(taskId, basePath);
+    try {
+        // Run the actual work (writes code, runs tests)
+        const commitMessage = await workCallback(worktreePath);
+        // Phase 3: Commit
+        const commitHash = await commitTask(taskId, commitMessage, basePath);
+        // Phase 4: Terminate (cleanup)
+        await terminate(taskId);
+        return commitHash;
+    }
+    catch (error) {
+        // On error, keep worktree for debugging
+        await terminate(taskId, true);
+        throw error;
+    }
+}
+//# sourceMappingURL=wipe-protocol.js.map

package/dist/git/wipe-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wipe-protocol.js","sourceRoot":"","sources":["../../src/git/wipe-protocol.ts"],"names":[],"mappings":"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"}

package/dist/git/worktree.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Git Worktree Management for FORGE
+ *
+ * Implements isolated worktree strategy for parallel agent execution.
+ * Each task gets its own worktree to prevent merge conflicts during development.
+ *
+ * Commands (from FORGE spec):
+ * - git worktree add .worktrees/{taskId} -b forge/{taskId}
+ * - git worktree remove .worktrees/{taskId}
+ */
+export interface WorktreeOptions {
+    taskId: string;
+    branchName?: string;
+    baseBranch?: string;
+}
+export interface WorktreeInfo {
+    taskId: string;
+    branchName: string;
+    path: string;
+    commit: string;
+}
+export declare class WorktreeError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/**
+ * Create a new git worktree for a task.
+ *
+ * Creates a branch `forge/{taskId}` and checks it out into `.worktrees/{taskId}`.
+ * This gives each agent an isolated filesystem to work in.
+ *
+ * @param options - Task identification and branch configuration
+ * @returns Path to the new worktree
+ * @throws WorktreeError if worktree creation fails
+ */
+export declare function createWorktree(options: WorktreeOptions): Promise<string>;
+/**
+ * Get information about a worktree.
+ *
+ * @param taskId - Task ID to look up
+ * @returns Worktree information or null if not found
+ */
+export declare function getWorktree(taskId: string): Promise<WorktreeInfo | null>;
+/**
+ * Merge a worktree's branch back into the base branch.
+ *
+ * Should only be called after CI passes. The worktree is removed after merge.
+ *
+ * @param taskId - Task ID whose branch to merge
+ * @param targetBranch - Branch to merge into (default: main)
+ * @throws WorktreeError if merge fails or has conflicts
+ */
+export declare function mergeWorktree(taskId: string, targetBranch?: string): Promise<void>;
+/**
+ * Remove a worktree.
+ *
+ * Safely removes the worktree after cleaning up any uncommitted changes.
+ *
+ * @param taskId - Task ID whose worktree to remove
+ * @throws WorktreeError if removal fails
+ */
+export declare function cleanupWorktree(taskId: string): Promise<void>;
+/**
+ * List all FORGE worktrees.
+ *
+ * @returns Array of worktree information for all active tasks
+ */
+export declare function listWorktrees(): Promise<WorktreeInfo[]>;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/git/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/git/worktree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAc,SAAQ,KAAK;aACO,IAAI,CAAC,EAAE,MAAM;gBAA9C,OAAO,EAAE,MAAM,EAAkB,IAAI,CAAC,EAAE,MAAM,YAAA;CAI3D;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAqB9E;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAyC9E;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,EACd,YAAY,GAAE,MAAe,GAC5B,OAAO,CAAC,IAAI,CAAC,CA0Bf;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBnE;AAED;;;;GAIG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CA4C7D"}