@cat-factory/orchestration 0.301.2 → 0.302.0

package/dist/modules/execution/bugFishingPass.js

@@ -0,0 +1,45 @@
+import { BUG_FISHING_TERRITORY_CONTEXT_FILE, renderBugFishingTerritoryContext, } from '@cat-factory/agents';
+/**
+ * Resolve the pass a planned phase describes against the survey.
+ *
+ * A phase with no `territoryId` is the PASS-THROUGH: a codebase small enough to fish whole, or an
+ * expedition planned before territories existed, or one whose survey could not read the
+ * repository. All three get no manifest, no scope and no territory in the brief, which is
+ * byte-for-byte the dispatch that shipped before this feature.
+ *
+ * A phase whose territory the CURRENT survey no longer produces (the tree moved between passes,
+ * or a fix merged and re-shaped a directory) falls back to the roots the run itself recorded, and
+ * gets no file manifest. That is deliberate: the run's own record is the better witness of what
+ * it planned, and a manifest re-derived from a different partition would describe a territory
+ * this pass was never given.
+ */
+export function bugFishingPassScope(state, phase, survey) {
+    const territoryId = phase.territoryId;
+    if (!territoryId)
+        return { territory: null, contextFile: null, scope: undefined };
+    const recorded = (state.territories ?? []).find((t) => t.id === territoryId);
+    const roots = recorded?.roots ?? [];
+    const label = phase.territoryLabel || recorded?.label || territoryId;
+    const files = (survey.filesByTerritory.get(territoryId) ?? []).map((file) => file.path);
+    const scope = { territoryId, roots, manifest: new Set(files) };
+    if (files.length === 0) {
+        // The survey has no manifest for this territory any more. The pass still owns the roots (the
+        // brief says so, and the scope enforces it); it just gets no map, which costs it the
+        // orientation saving rather than its correctness.
+        return { territory: { label, roots }, contextFile: null, scope };
+    }
+    const contextFile = {
+        path: BUG_FISHING_TERRITORY_CONTEXT_FILE,
+        content: renderBugFishingTerritoryContext({
+            territory: {
+                label,
+                roots,
+                ...(recorded?.approxTokens !== undefined ? { approxTokens: recorded.approxTokens } : {}),
+            },
+            files,
+            neighbours: (state.territories ?? []).filter((t) => t.id !== territoryId).map((t) => t.label),
+        }),
+    };
+    return { territory: { label, roots }, contextFile, scope };
+}
+//# sourceMappingURL=bugFishingPass.js.map

package/dist/modules/execution/bugFishingPass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bugFishingPass.js","sourceRoot":"","sources":["../../../src/modules/execution/bugFishingPass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,qBAAqB,CAAA;AA4B5B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAA0B,EAC1B,KAAsB,EACtB,MAA4B;IAE5B,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAA;IACrC,IAAI,CAAC,WAAW;QAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAA;IACjF,MAAM,QAAQ,GAAG,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,WAAW,CAAC,CAAA;IAC5E,MAAM,KAAK,GAAG,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAA;IACnC,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,IAAI,QAAQ,EAAE,KAAK,IAAI,WAAW,CAAA;IACpE,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACvF,MAAM,KAAK,GAAwB,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,EAAE,CAAA;IACnF,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,6FAA6F;QAC7F,qFAAqF;QACrF,kDAAkD;QAClD,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;IAClE,CAAC;IACD,MAAM,WAAW,GAAwB;QACvC,IAAI,EAAE,kCAAkC;QACxC,OAAO,EAAE,gCAAgC,CAAC;YACxC,SAAS,EAAE;gBACT,KAAK;gBACL,KAAK;gBACL,GAAG,CAAC,QAAQ,EAAE,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACzF;YACD,KAAK;YACL,UAAU,EAAE,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;SAC9F,CAAC;KACH,CAAA;IACD,OAAO,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,CAAA;AAC5D,CAAC"}

package/dist/modules/execution/bugFishingSurvey.d.ts

@@ -0,0 +1,87 @@
+import type { BugFishingTerritory, Logger, RepoFiles, RunRepoContext } from '@cat-factory/kernel';
+import { type SurveyedFile } from './bugFishingTerritories.logic.js';
+/** What a survey produced, plus what it could not do. */
+export interface CodebaseSurveyResult {
+    /** The partition, most worth fishing first once the caller has prioritised it. */
+    territories: BugFishingTerritory[];
+    /**
+     * Every fishable file of each territory, for the manifest and the coverage intersection. Paths
+     * are relative to the SURVEY ROOT (the service's own directory in a monorepo), which is the
+     * frame the agent's checkout is rooted at.
+     */
+    filesByTerritory: Map<string, SurveyedFile[]>;
+    /** True when the provider cut the tree short: the territories cover a PREFIX of the codebase. */
+    treeTruncated: boolean;
+    /**
+     * Why the survey could not read the codebase, when it could not. Null on a real survey.
+     *
+     * Stated rather than left for the one-territory plan to imply, because the plan is the same
+     * VALUE for opposite FACTS: "this repository is small enough to fish whole" and "nobody could
+     * see this repository" produce an identical partition, and only the second is something a human
+     * has to act on.
+     */
+    unavailableReason: string | null;
+}
+/** What the survey needs to read a codebase. */
+export interface CodebaseSurveyInput {
+    /**
+     * The run's checkout-free repo facade, or null when no repository resolves for the block (no
+     * VCS connected, or the deployment wires no repo context).
+     */
+    repo: RepoFiles | null;
+    /** The branch the expedition fishes: the base branch its read-only clone is taken from. */
+    branch: string;
+    /** The monorepo subdirectory the service lives in, when it has one. */
+    serviceDirectory?: string | null;
+    logger?: Logger;
+}
+/**
+ * The survey a caller gets when the codebase cannot be read: ONE whole-codebase territory,
+ * carrying the reason.
+ *
+ * A pass-through is the correct disposition for an unwired capability, and it must be invisible
+ * to the domain: the expedition this plans is byte-for-byte the eight-angle hunt that shipped
+ * before territories existed. What it must not be is silent, which is what `reason` is for.
+ *
+ * ONE territory rather than none, and the difference is not cosmetic: an empty list is what the
+ * step then persists as `territories: []`, the value the schema documents as forbidden because it
+ * claims the codebase was surveyed and found to contain nothing, and it is also what leaves the
+ * planner with no cell to name when the pass budget cuts an angle. The territory's counts are
+ * zero because nobody could count them; `unavailableReason` is what says so, and it is the only
+ * thing that tells this apart from a genuinely tiny repository.
+ *
+ * Exported because the seam that RESOLVES the run's repository sits outside this module and can
+ * fail on its own terms (an unlinked block chain refuses with a `ValidationError`), and this
+ * module's contract is that a survey never throws. That caller states its own reason through here
+ * rather than rebuilding the shape.
+ */
+export declare function unavailableSurvey(reason: string): CodebaseSurveyResult;
+/**
+ * Read the repository tree and partition it into territories.
+ *
+ * Never throws: a tree read that fails degrades to the whole-codebase expedition WITH the cause
+ * recorded, because an expedition that cannot be partitioned is still worth running and a run
+ * that failed at planning because a contents API blipped is not. The blueprint read degrades the
+ * same way, one level finer: no blueprint means the directory heuristic, which is what a
+ * repository that was never blueprinted gets anyway.
+ */
+export declare function surveyCodebase(input: CodebaseSurveyInput): Promise<CodebaseSurveyResult>;
+/**
+ * Survey the codebase a RUN targets: resolve its repository, then partition the tree.
+ *
+ * The repo resolution is its own refusal and does not belong to a survey. An unlinked block chain
+ * throws a `ValidationError` rather than answering null, deliberately, because guessing a repo once
+ * pushed a task into someone else's; that refusal belongs to a DISPATCH, where a human can act on
+ * it. This module's contract is the opposite one, that a survey never throws, and its callers
+ * include the COMPLETION path of a pass that has already run and has nothing left to refuse.
+ *
+ * Here rather than on the dispatcher so the two halves of "never throws" sit together, and so the
+ * dispatcher keeps only the binding: which repo resolver, which logger.
+ */
+export declare function surveyRunCodebase(input: {
+    /** The run's repo resolution, bound to one workspace and block by the caller. */
+    resolveRunRepo: () => Promise<RunRepoContext | null>;
+    /** Bind the block id on it: everything below logs into this scope. */
+    logger?: Logger;
+}): Promise<CodebaseSurveyResult>;
+//# sourceMappingURL=bugFishingSurvey.d.ts.map

package/dist/modules/execution/bugFishingSurvey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bugFishingSurvey.d.ts","sourceRoot":"","sources":["../../../src/modules/execution/bugFishingSurvey.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,mBAAmB,EACnB,MAAM,EACN,SAAS,EACT,cAAc,EACf,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,kCAAkC,CAAA;AAiBzC,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACnC,kFAAkF;IAClF,WAAW,EAAE,mBAAmB,EAAE,CAAA;IAClC;;;;OAIG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAA;IAC7C,iGAAiG;IACjG,aAAa,EAAE,OAAO,CAAA;IACtB;;;;;;;OAOG;IACH,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;CACjC;AAED,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,2FAA2F;IAC3F,MAAM,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAQtE;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAgC9F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE;IAC7C,iFAAiF;IACjF,cAAc,EAAE,MAAM,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IACpD,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAiBhC"}

package/dist/modules/execution/bugFishingSurvey.js

@@ -0,0 +1,130 @@
+import { BLUEPRINT_JSON_PATH, safeParseBlueprintService } from '@cat-factory/contracts';
+import { describeError, noopLogger } from '@cat-factory/kernel';
+import { partitionCodebase, wholeCodebaseTerritory, } from './bugFishingTerritories.logic.js';
+/**
+ * The survey a caller gets when the codebase cannot be read: ONE whole-codebase territory,
+ * carrying the reason.
+ *
+ * A pass-through is the correct disposition for an unwired capability, and it must be invisible
+ * to the domain: the expedition this plans is byte-for-byte the eight-angle hunt that shipped
+ * before territories existed. What it must not be is silent, which is what `reason` is for.
+ *
+ * ONE territory rather than none, and the difference is not cosmetic: an empty list is what the
+ * step then persists as `territories: []`, the value the schema documents as forbidden because it
+ * claims the codebase was surveyed and found to contain nothing, and it is also what leaves the
+ * planner with no cell to name when the pass budget cuts an angle. The territory's counts are
+ * zero because nobody could count them; `unavailableReason` is what says so, and it is the only
+ * thing that tells this apart from a genuinely tiny repository.
+ *
+ * Exported because the seam that RESOLVES the run's repository sits outside this module and can
+ * fail on its own terms (an unlinked block chain refuses with a `ValidationError`), and this
+ * module's contract is that a survey never throws. That caller states its own reason through here
+ * rather than rebuilding the shape.
+ */
+export function unavailableSurvey(reason) {
+    const only = wholeCodebaseTerritory([]);
+    return {
+        territories: [only],
+        filesByTerritory: new Map([[only.id, []]]),
+        treeTruncated: false,
+        unavailableReason: reason,
+    };
+}
+/**
+ * Read the repository tree and partition it into territories.
+ *
+ * Never throws: a tree read that fails degrades to the whole-codebase expedition WITH the cause
+ * recorded, because an expedition that cannot be partitioned is still worth running and a run
+ * that failed at planning because a contents API blipped is not. The blueprint read degrades the
+ * same way, one level finer: no blueprint means the directory heuristic, which is what a
+ * repository that was never blueprinted gets anyway.
+ */
+export async function surveyCodebase(input) {
+    const log = input.logger ?? noopLogger;
+    const repo = input.repo;
+    if (!repo)
+        return unavailableSurvey('No repository is linked to this task, so the codebase was not surveyed.');
+    if (!repo.listTree) {
+        return unavailableSurvey('The connected VCS client cannot list a repository tree, so the codebase was not surveyed.');
+    }
+    let tree;
+    try {
+        tree = await repo.listTree(input.branch);
+    }
+    catch (error) {
+        log.warn('bugFishing.treeReadFailed', { branch: input.branch, ...describeError(error) });
+        return unavailableSurvey('The repository tree could not be read, so the codebase was not surveyed.');
+    }
+    const blueprint = await readBlueprint(repo, input.branch, log);
+    const survey = partitionCodebase(tree, {
+        serviceDirectory: input.serviceDirectory ?? null,
+        blueprint,
+    });
+    return {
+        territories: survey.territories,
+        filesByTerritory: survey.filesByTerritory,
+        treeTruncated: survey.treeTruncated,
+        unavailableReason: null,
+    };
+}
+/**
+ * Survey the codebase a RUN targets: resolve its repository, then partition the tree.
+ *
+ * The repo resolution is its own refusal and does not belong to a survey. An unlinked block chain
+ * throws a `ValidationError` rather than answering null, deliberately, because guessing a repo once
+ * pushed a task into someone else's; that refusal belongs to a DISPATCH, where a human can act on
+ * it. This module's contract is the opposite one, that a survey never throws, and its callers
+ * include the COMPLETION path of a pass that has already run and has nothing left to refuse.
+ *
+ * Here rather than on the dispatcher so the two halves of "never throws" sit together, and so the
+ * dispatcher keeps only the binding: which repo resolver, which logger.
+ */
+export async function surveyRunCodebase(input) {
+    const log = input.logger ?? noopLogger;
+    let runRepo;
+    try {
+        runRepo = await input.resolveRunRepo();
+    }
+    catch (error) {
+        log.warn('bugFishing.repoResolveFailed', describeError(error));
+        return unavailableSurvey('The repository this task targets could not be resolved, so the codebase was not surveyed.');
+    }
+    return surveyCodebase({
+        repo: runRepo?.repo ?? null,
+        branch: runRepo?.baseBranch ?? 'HEAD',
+        serviceDirectory: runRepo?.serviceDirectory ?? null,
+        logger: log,
+    });
+}
+/**
+ * The service's committed blueprint, or null.
+ *
+ * Read at the REPOSITORY root, because that is where `blueprintPostOp` commits it: the post-op
+ * writes {@link BLUEPRINT_JSON_PATH} through a root-scoped `RepoFiles`, with no service prefix,
+ * whatever subdirectory the service that produced it lives in. Reading it under the service
+ * directory found nothing on every monorepo service, and found it silently: a blueprinted service
+ * fell through to the directory heuristic with nothing saying it had one. The constant is imported
+ * rather than restated so the reader cannot drift from the writer again.
+ *
+ * The blueprint is a DECOMPOSITION first and a file map second: its `references` were written by
+ * a model against an older tree, so the partition drops a reference the tree no longer has rather
+ * than trusting it, and a blueprint that parses to nothing usable is simply no blueprint. A read
+ * failure is the same answer for the same reason: the directory heuristic is a complete fallback,
+ * not a degraded one.
+ */
+async function readBlueprint(repo, branch, log) {
+    try {
+        const file = await repo.getFile(BLUEPRINT_JSON_PATH, branch);
+        if (!file?.content)
+            return null;
+        return safeParseBlueprintService(JSON.parse(file.content)) ?? null;
+    }
+    catch (error) {
+        log.warn('bugFishing.blueprintReadFailed', {
+            path: BLUEPRINT_JSON_PATH,
+            ...describeError(error),
+        });
+        return null;
+    }
+}
+//# sourceMappingURL=bugFishingSurvey.js.map

package/dist/modules/execution/bugFishingSurvey.js.map

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

package/dist/modules/execution/bugFishingTerritories.logic.d.ts

@@ -0,0 +1,89 @@
+import type { BlueprintService, BugFishingPhase, BugFishingTerritory, BugFishingUnfishedCell, RepoTreeListing } from '@cat-factory/kernel';
+/** Whether a repo-relative path is source the expedition should fish. */
+export declare function isFishablePath(path: string): boolean;
+/** One file of the survey's manifest: the path (survey-root-relative), and what it weighs. */
+export interface SurveyedFile {
+    path: string;
+    bytes: number;
+}
+/** What a survey of the repository tree produced. */
+export interface CodebaseSurvey {
+    /** The partition, in the order the expedition fishes it. Always at least one entry. */
+    territories: BugFishingTerritory[];
+    /**
+     * Every fishable file under the survey root, indexed by territory id, with paths in the survey
+     * root's frame (see this module's header).
+     */
+    filesByTerritory: Map<string, SurveyedFile[]>;
+    /** True when the provider cut the tree short: the manifest is a prefix of the codebase. */
+    treeTruncated: boolean;
+}
+/** Options a survey takes beyond the tree itself. */
+export interface SurveyOptions {
+    /**
+     * The monorepo subdirectory the service lives in, when it has one. The survey walks from here
+     * rather than from the repository root: a sibling service's code is out of scope for an
+     * expedition exactly as it is for every other run. It is also the frame every path this module
+     * emits is relative to, because it is the directory the agent's checkout is rooted at.
+     */
+    serviceDirectory?: string | null;
+    /**
+     * The service's committed blueprint, when the repository has one. Its modules are the
+     * platform's own decomposition and win over the directory heuristic; a module whose references
+     * the tree no longer has falls through to the directory rule rather than being guessed onto a
+     * new home.
+     */
+    blueprint?: BlueprintService | null;
+}
+/**
+ * The single territory a codebase small enough to fish whole gets.
+ *
+ * The PASS-THROUGH: its phases carry no territory id, so the expedition is byte-for-byte the one
+ * that shipped before territories existed. Large-codebase mode is a size threshold crossed, never
+ * a mode a task opts into.
+ */
+export declare function wholeCodebaseTerritory(files: readonly SurveyedFile[]): BugFishingTerritory;
+/**
+ * Partition a repository tree into the territories an expedition fishes.
+ *
+ * Blueprint modules first when the repository has a blueprint, then package and directory
+ * boundaries under the survey root, sized by the tree's blob bytes. A codebase that fits one
+ * territory yields exactly one, and the expedition it plans is today's.
+ */
+export declare function partitionCodebase(tree: RepoTreeListing, options?: SurveyOptions): CodebaseSurvey;
+/** One planned cell: an angle fished over a territory. */
+export interface PlannedCell {
+    territory: BugFishingTerritory;
+    phase: BugFishingPhase;
+}
+/**
+ * Build the pass list from the territories and the angles, TERRITORY-MAJOR, trimmed to the pass
+ * budget.
+ *
+ * Territory-major so a human gets a complete answer for one territory early and can start its
+ * fixes while the rest is still being fished, which is what the separate-dispatch design is for.
+ * The budget trims from the BOTTOM of the order rather than the middle, and what it cuts is
+ * returned as unfished: a cap silent about its tail teaches the reader that the tail was clean.
+ *
+ * A single whole-codebase territory yields the angles unchanged, with no territory stamped on
+ * them, so a small codebase's plan is field-for-field the one that shipped before territories.
+ */
+export declare function planTerritoryPasses(input: {
+    territories: readonly BugFishingTerritory[];
+    angles: readonly BugFishingPhase[];
+    passBudget: number;
+}): {
+    phases: BugFishingPhase[];
+    unfished: BugFishingUnfishedCell[];
+    plannedCells: number;
+};
+/**
+ * Order the territories a large expedition fishes, most worth fishing first.
+ *
+ * The creator's `fishingFocus` comes first, because naming a subsystem is the deliberate act and
+ * a budget that cut it would be cutting the one thing they asked for. Size decides the rest: with
+ * no scout rating relevance yet, the biggest territory is the one most likely to hide something,
+ * and it is a fact the platform can compute rather than a judgement it would be inventing.
+ */
+export declare function prioritiseTerritories(territories: readonly BugFishingTerritory[], focus: string | null | undefined): BugFishingTerritory[];
+//# sourceMappingURL=bugFishingTerritories.logic.d.ts.map

package/dist/modules/execution/bugFishingTerritories.logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bugFishingTerritories.logic.d.ts","sourceRoot":"","sources":["../../../src/modules/execution/bugFishingTerritories.logic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EAEtB,eAAe,EAChB,MAAM,qBAAqB,CAAA;AA0I5B,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOpD;AAED,8FAA8F;AAC9F,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC7B,uFAAuF;IACvF,WAAW,EAAE,mBAAmB,EAAE,CAAA;IAClC;;;OAGG;IACH,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAA;IAC7C,2FAA2F;IAC3F,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAA;CACpC;AA+ED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,mBAAmB,CAU1F;AAsND;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,eAAe,EACrB,OAAO,GAAE,aAAkB,GAC1B,cAAc,CAuChB;AAID,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,mBAAmB,CAAA;IAC9B,KAAK,EAAE,eAAe,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAA;IAC3C,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;IAClC,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG;IAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAgC1F;AAWD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,SAAS,mBAAmB,EAAE,EAC3C,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,mBAAmB,EAAE,CAiBvB"}