@petepetrash/circuit 0.1.0

package/dist/flows/sweep/data.d.ts

@@ -0,0 +1,552 @@
+export declare const sweepFlowData: {
+    id: string;
+    visibility: "internal";
+    paths: {
+        schematic: string;
+    };
+    schematic: {
+        schema_version: "2";
+        id: string & import("zod").$brand<"CompiledFlowId">;
+        title: string;
+        purpose: string;
+        status: "deprecated" | "candidate" | "active";
+        starts_at: string & import("zod").$brand<"StepId">;
+        initial_contracts: string[];
+        contract_aliases: {
+            generic: string;
+            actual: string;
+        }[];
+        items: {
+            id: string & import("zod").$brand<"StepId">;
+            block: "handoff" | "goal" | "route" | "review" | "frame" | "plan" | "act" | "intake" | "clarify" | "human-decision" | "gather-context" | "diagnose" | "run-verification" | "goal-child-run" | "goal-attempt" | "goal-evaluate" | "goal-recover" | "goal-checkpoint" | "goal-gate-review" | "goal-close" | "pursue" | "coordinate-pursuits" | "queue" | "batch" | "risk-rollback-check" | "close-with-evidence" | "review-intake" | "prototype-variant-evidence" | "prototype-checkpoint";
+            title: string;
+            stage: "review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close";
+            input: Record<string, string>;
+            optional_inputs: string[];
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+            } | {
+                kind: "relay";
+                role: "researcher" | "implementer" | "reviewer";
+                connector?: string | undefined;
+            } | {
+                kind: "verification";
+            } | {
+                kind: "checkpoint";
+            } | {
+                kind: "sub-run";
+                flow_ref: {
+                    flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                    entry_mode: string;
+                    version?: string | undefined;
+                };
+                goal: string;
+                depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+            } | {
+                kind: "fanout";
+            };
+            skill_slots: {
+                id: string & import("zod").$brand<"SkillSlotId">;
+                description: string;
+            }[];
+            routes: Record<string, (string & import("zod").$brand<"StepId">) | "@complete" | "@stop" | "@handoff" | "@escalate">;
+            route_overrides: Record<string, Partial<Record<"low" | "medium" | "high" | "tournament" | "autonomous", (string & import("zod").$brand<"StepId">) | "@complete" | "@stop" | "@handoff" | "@escalate">>>;
+            selection?: {
+                skills: {
+                    mode: "inherit";
+                } | {
+                    mode: "replace";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                } | {
+                    mode: "append";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                } | {
+                    mode: "remove";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                };
+                invocation_options: import("../../index.js").JsonObject;
+                model?: {
+                    provider: "custom" | "openai" | "anthropic" | "gemini";
+                    model: string;
+                } | undefined;
+                effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+            } | undefined;
+            equipment_scope?: {
+                tools: {
+                    allow: string[];
+                } | "full";
+                enforcement: "trusted" | "enforced";
+            } | undefined;
+            route_from_report?: {
+                path: string[];
+            } | undefined;
+            protocol?: (string & import("zod").$brand<"ProtocolId">) | undefined;
+            writes?: {
+                report_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                request_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                receipt_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                result_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                branches_dir_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                checkpoint_request_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                checkpoint_response_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+            } | undefined;
+            check?: {
+                required?: string[] | undefined;
+                allow?: string[] | undefined;
+                allow_from?: {
+                    kind: "policy_choices";
+                } | undefined;
+                pass?: string[] | undefined;
+            } | undefined;
+            acceptance_criteria?: {
+                checks: ({
+                    kind: "command";
+                    id: string;
+                    command: {
+                        id: string;
+                        cwd: string;
+                        argv: string[];
+                        timeout_ms: number;
+                        max_output_bytes: number;
+                        env: Record<string, string>;
+                    };
+                    expected_status: "passed";
+                } | {
+                    kind: "report_field";
+                    id: string;
+                    path: string[];
+                    predicate: "present" | "non_empty" | "changed_on_disk";
+                })[];
+                on_failure: {
+                    mode: "hard-fail";
+                } | {
+                    mode: "retry-with-feedback";
+                };
+            } | undefined;
+            checkpoint_policy?: {
+                prompt: string;
+                choices?: {
+                    id: string;
+                    label?: string | undefined;
+                    description?: string | undefined;
+                }[] | undefined;
+                choices_from?: {
+                    kind: "report_items";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    items_path: string;
+                    id_path: string;
+                    filter?: {
+                        kind: "path_equals";
+                        path: string;
+                        value: string | number | boolean | null;
+                    } | undefined;
+                    required_count?: {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    } | undefined;
+                    label_path?: string | undefined;
+                    description_path?: string | undefined;
+                } | undefined;
+                safe_default_choice?: string | undefined;
+                auto_resolution?: {
+                    policy: "highest-score";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    branches_path: string;
+                    id_path: string;
+                    rubric_result_path: string;
+                } | undefined;
+                auto_continuable_when_nested?: boolean | undefined;
+                report_template?: import("../../index.js").JsonObject | undefined;
+            } | undefined;
+            fanout?: {
+                branches: {
+                    kind: "static";
+                    branches: ({
+                        branch_id: string;
+                        flow_ref: {
+                            flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                            entry_mode: string;
+                            version?: string | undefined;
+                        };
+                        goal: string;
+                        depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+                        selection?: {
+                            skills: {
+                                mode: "inherit";
+                            } | {
+                                mode: "replace";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "append";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "remove";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            };
+                            invocation_options: import("../../index.js").JsonObject;
+                            model?: {
+                                provider: "custom" | "openai" | "anthropic" | "gemini";
+                                model: string;
+                            } | undefined;
+                            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+                        } | undefined;
+                    } | {
+                        branch_id: string;
+                        execution: {
+                            kind: "relay";
+                            role: "researcher" | "implementer" | "reviewer";
+                            goal: string;
+                            report_schema: string;
+                            provenance_field?: string | undefined;
+                        };
+                        connector?: string | undefined;
+                        selection?: {
+                            skills: {
+                                mode: "inherit";
+                            } | {
+                                mode: "replace";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "append";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "remove";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            };
+                            invocation_options: import("../../index.js").JsonObject;
+                            model?: {
+                                provider: "custom" | "openai" | "anthropic" | "gemini";
+                                model: string;
+                            } | undefined;
+                            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+                        } | undefined;
+                    })[];
+                } | {
+                    kind: "dynamic";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    items_path: string;
+                    template: {
+                        branch_id: string;
+                        flow_ref: {
+                            flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                            entry_mode: string;
+                            version?: string | undefined;
+                        };
+                        goal: string;
+                        depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+                        selection?: unknown;
+                    } | {
+                        branch_id: string;
+                        execution: {
+                            kind: "relay";
+                            role: "researcher" | "implementer" | "reviewer";
+                            goal: string;
+                            report_schema: string;
+                            provenance_field?: string | undefined;
+                        };
+                        connector?: string | undefined;
+                        selection?: unknown;
+                    };
+                    max_branches: number | {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    };
+                    required_count?: {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    } | undefined;
+                };
+                join: {
+                    policy: "pick-winner";
+                } | {
+                    policy: "disjoint-merge";
+                } | {
+                    policy: "aggregate-only";
+                } | {
+                    policy: "aggregate-survivors";
+                };
+                concurrency?: {
+                    kind: "unbounded";
+                } | {
+                    kind: "bounded";
+                    max: number;
+                } | undefined;
+                on_child_failure?: "abort-all" | "continue-others" | undefined;
+                rubric?: {
+                    model_judgments_path: string;
+                    ordered_dims: string[];
+                    runtime_signals: Record<string, {
+                        kind: "constant";
+                        signal: "met" | "missing" | "n/a";
+                    } | {
+                        kind: "non_empty_array";
+                        path: string;
+                    } | {
+                        kind: "non_empty_string";
+                        path: string;
+                    }>;
+                } | undefined;
+            } | undefined;
+        }[];
+        version?: string | undefined;
+        axes?: {
+            allowed_depths: ("low" | "medium" | "high")[];
+            supports_tournament: boolean;
+            supports_autonomous: boolean;
+            default: {
+                depth: "low" | "medium" | "high";
+                tournament: boolean;
+                tournament_n: number;
+                autonomous: boolean;
+            };
+            tournament_fan_out_stage?: (string & import("zod").$brand<"StageId">) | undefined;
+        } | undefined;
+        stage_path_policy?: {
+            mode: "strict";
+        } | {
+            mode: "partial";
+            omits: ("review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close")[];
+            rationale: string;
+        } | undefined;
+        stages?: {
+            canonical: "review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close";
+            id: string & import("zod").$brand<"StageId">;
+            title: string;
+        }[] | undefined;
+        default_selection?: {
+            skills: {
+                mode: "inherit";
+            } | {
+                mode: "replace";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            } | {
+                mode: "append";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            } | {
+                mode: "remove";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            };
+            invocation_options: import("../../index.js").JsonObject;
+            model?: {
+                provider: "custom" | "openai" | "anthropic" | "gemini";
+                model: string;
+            } | undefined;
+            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+        } | undefined;
+        engine_flags?: {
+            binds_execution_depth_to_relay_selection?: boolean | undefined;
+            binds_terminal_outcome_to_primary_result?: boolean | undefined;
+            iterates_slice_loop?: {
+                head_step: string;
+                tail_step: string;
+                advance_route: string;
+                slices_from: {
+                    report: string;
+                    items_path: string;
+                };
+                max_slices: number;
+                activate_when_depth_at_least: "high";
+            } | undefined;
+            iterates_until_condition?: {
+                head_step: string;
+                tail_step: string;
+                body_steps: string[];
+                reenter_route: string;
+                max_iterations: number;
+                activate_when_depth_at_least: "autonomous";
+                stop_judge?: {
+                    report: string;
+                    goal_met_path: string;
+                    lesson_path?: string | undefined;
+                    progress_path?: string | undefined;
+                } | undefined;
+                needs_attention_route?: string | undefined;
+                carried_notes?: {
+                    report: string;
+                    max_entries?: number | undefined;
+                } | undefined;
+                cumulative_usd_cap?: number | undefined;
+                cumulative_token_cap?: number | undefined;
+                no_progress_ceiling?: number | undefined;
+                iteration_commit_containment?: {
+                    branch_prefix: string;
+                } | undefined;
+                frozen_paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+        report_file_surfaces?: Record<string, {
+            timing: "before" | "after";
+            extractor: {
+                kind: "string-array-field";
+                field: string;
+            } | {
+                kind: "build-plan-and-slices-anticipated-file-extensions";
+            };
+        }> | undefined;
+        required_config?: {
+            axis: "tournament" | "autonomous";
+            path: string;
+            message: string;
+        }[] | undefined;
+    };
+    canonicalStagePolicy: {
+        kind: "exempt";
+        reason: string;
+    };
+    reports: ({
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            objective: import("zod").ZodString;
+            scanner: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                cwd: import("zod").ZodString;
+                argv: import("zod").ZodArray<import("zod").ZodString>;
+                timeout_ms: import("zod").ZodNumber;
+                max_output_bytes: import("zod").ZodNumber;
+                env: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            suppression_audit: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                cwd: import("zod").ZodString;
+                argv: import("zod").ZodArray<import("zod").ZodString>;
+                timeout_ms: import("zod").ZodNumber;
+                max_output_bytes: import("zod").ZodNumber;
+                env: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>;
+            suppression_baseline: import("zod").ZodNumber;
+            config_surface: import("zod").ZodArray<import("zod").ZodString>;
+            findings: import("zod").ZodArray<import("zod").ZodObject<{
+                finding_id: import("zod").ZodString;
+                file: import("zod").ZodNullable<import("zod").ZodString>;
+                rule: import("zod").ZodString;
+                message: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            total_finding_count: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            units: import("zod").ZodArray<import("zod").ZodObject<{
+                unit_id: import("zod").ZodString;
+                files: import("zod").ZodArray<import("zod").ZodString>;
+                finding_ids: import("zod").ZodArray<import("zod").ZodString>;
+                independence: import("zod").ZodEnum<{
+                    project: "project";
+                    serial: "serial";
+                    isolated: "isolated";
+                    shared: "shared";
+                }>;
+                fix_prompt: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            covers_all_findings: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+        };
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            schema_version: import("zod").ZodLiteral<1>;
+            join_policy: import("zod").ZodLiteral<"aggregate-only">;
+            branch_count: import("zod").ZodNumber;
+            branches: import("zod").ZodArray<import("zod").ZodObject<{
+                branch_id: import("zod").ZodString;
+                child_run_id: import("zod").ZodString;
+                child_outcome: import("zod").ZodEnum<{
+                    complete: "complete";
+                    stopped: "stopped";
+                    handoff: "handoff";
+                    aborted: "aborted";
+                    escalated: "escalated";
+                }>;
+                verdict: import("zod").ZodString;
+                admitted: import("zod").ZodBoolean;
+                result_path: import("zod").ZodString;
+                duration_ms: import("zod").ZodNumber;
+                result_body: import("zod").ZodOptional<import("zod").ZodObject<{
+                    unit_id: import("zod").ZodString;
+                    verdict: import("zod").ZodEnum<{
+                        fixed: "fixed";
+                        partial: "partial";
+                        blocked: "blocked";
+                    }>;
+                    changed_files: import("zod").ZodArray<import("zod").ZodString>;
+                    rule_fixed: import("zod").ZodString;
+                    evidence: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers?: never;
+        relayHint?: never;
+    } | {
+        schemaName: string;
+        channel: "relay";
+        schema: import("zod").ZodObject<{
+            unit_id: import("zod").ZodString;
+            verdict: import("zod").ZodEnum<{
+                fixed: "fixed";
+                partial: "partial";
+                blocked: "blocked";
+            }>;
+            changed_files: import("zod").ZodArray<import("zod").ZodString>;
+            rule_fixed: import("zod").ZodString;
+            evidence: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+        relayHint: string;
+        writers?: never;
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            overall_status: import("zod").ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>;
+            commands: import("zod").ZodArray<import("zod").ZodObject<{
+                command_id: import("zod").ZodString;
+                argv: import("zod").ZodArray<import("zod").ZodString>;
+                cwd: import("zod").ZodString;
+                exit_code: import("zod").ZodNumber;
+                status: import("zod").ZodEnum<{
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                duration_ms: import("zod").ZodNumber;
+                stdout_summary: import("zod").ZodString;
+                stderr_summary: import("zod").ZodString;
+                timed_out: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            verification: import("../registries/verification-writers/types.js").VerificationBuilder[];
+            compose?: never;
+        };
+        relayHint?: never;
+    })[];
+};
+//# sourceMappingURL=data.d.ts.map

package/dist/flows/sweep/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/flows/sweep/data.ts"],"names":[],"mappings":"AAyEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAON,CAAC"}

package/dist/flows/sweep/data.js

@@ -0,0 +1,70 @@
+import { assembleFlowSchematic } from '../assemble-flow-schematic.js';
+import { sweepAssemblySpec } from './assembly-spec.js';
+import { sweepUnitFixShapeHint } from './relay-hints.js';
+import { SweepCensus, SweepPartition, SweepUnitFix, SweepVerification, SweepWaveAggregate, } from './reports.js';
+import { sweepCensusComposeBuilder } from './writers/census.js';
+import { sweepPartitionComposeBuilder } from './writers/partition.js';
+import { sweepRescanVerificationWriter } from './writers/verification.js';
+const sweepPaths = {
+    schematic: 'src/flows/sweep/schematic.json',
+};
+// First-class composition: sweep is an assembler customer, like fix-until-green.
+// Its block sequence and the until-loop engine flag live in ./assembly-spec.ts;
+// `assembleFlowSchematic` derives starts_at / stages / stage_path_policy and
+// carries the until flag through to the returned FlowSchematic.
+const sweepSchematic = assembleFlowSchematic(sweepAssemblySpec);
+const sweepCanonicalStagePolicy = {
+    kind: 'exempt',
+    reason: 'partial-stage path, recorded',
+};
+// Sweep owns the `sweep.*` schema names on the global compose, verification, and
+// report-schema registries. Five reports:
+//   sweep.census@v1     — compose. The preamble; pins the oracle commands.
+//   sweep.partition@v1  — compose. The loop head; re-scans and groups survivors.
+//   sweep.wave-aggregate@v1 — the engine's fanout aggregate (no writer; the
+//     fanout executor writes it after joining the wave).
+//   sweep.unit-fix@v1   — relay. A fanout worker's typed report; the relayHint
+//     tells the worker the exact JSON shape to emit.
+//   sweep.verification@v1 — verification. The rescan floor the until-loop reads.
+// The judge tail's converge.judgment@v1 is a built-in contract; fix-until-green
+// registers its structural shape hint globally, so sweep does not restate it.
+const sweepReports = [
+    {
+        schemaName: 'sweep.census@v1',
+        channel: 'report',
+        schema: SweepCensus,
+        writers: { compose: [sweepCensusComposeBuilder] },
+    },
+    {
+        schemaName: 'sweep.partition@v1',
+        channel: 'report',
+        schema: SweepPartition,
+        writers: { compose: [sweepPartitionComposeBuilder] },
+    },
+    {
+        schemaName: 'sweep.wave-aggregate@v1',
+        channel: 'report',
+        schema: SweepWaveAggregate,
+    },
+    {
+        schemaName: 'sweep.unit-fix@v1',
+        channel: 'relay',
+        schema: SweepUnitFix,
+        relayHint: sweepUnitFixShapeHint.instruction,
+    },
+    {
+        schemaName: 'sweep.verification@v1',
+        channel: 'report',
+        schema: SweepVerification,
+        writers: { verification: [sweepRescanVerificationWriter] },
+    },
+];
+export const sweepFlowData = {
+    id: 'sweep',
+    visibility: 'internal',
+    paths: sweepPaths,
+    schematic: sweepSchematic,
+    canonicalStagePolicy: sweepCanonicalStagePolicy,
+    reports: sweepReports,
+};
+//# sourceMappingURL=data.js.map

package/dist/flows/sweep/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","sourceRoot":"","sources":["../../../src/flows/sweep/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EACL,WAAW,EACX,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAE1E,MAAM,UAAU,GAAG;IACjB,SAAS,EAAE,gCAAgC;CAChB,CAAC;AAE9B,iFAAiF;AACjF,gFAAgF;AAChF,6EAA6E;AAC7E,gEAAgE;AAChE,MAAM,cAAc,GAAG,qBAAqB,CAAC,iBAAiB,CAAiC,CAAC;AAEhG,MAAM,yBAAyB,GAAG;IAChC,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,8BAA8B;CACI,CAAC;AAE7C,iFAAiF;AACjF,0CAA0C;AAC1C,2EAA2E;AAC3E,iFAAiF;AACjF,4EAA4E;AAC5E,yDAAyD;AACzD,+EAA+E;AAC/E,qDAAqD;AACrD,iFAAiF;AACjF,gFAAgF;AAChF,8EAA8E;AAC9E,MAAM,YAAY,GAAG;IACnB;QACE,UAAU,EAAE,iBAAiB;QAC7B,OAAO,EAAE,QAAQ;QACjB,MAAM,EAAE,WAAW;QACnB,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,yBAAyB,CAAC,EAAE;KAClD;IACD;QACE,UAAU,EAAE,oBAAoB;QAChC,OAAO,EAAE,QAAQ;QACjB,MAAM,EAAE,cAAc;QACtB,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,4BAA4B,CAAC,EAAE;KACrD;IACD;QACE,UAAU,EAAE,yBAAyB;QACrC,OAAO,EAAE,QAAQ;QACjB,MAAM,EAAE,kBAAkB;KAC3B;IACD;QACE,UAAU,EAAE,mBAAmB;QAC/B,OAAO,EAAE,OAAO;QAChB,MAAM,EAAE,YAAY;QACpB,SAAS,EAAE,qBAAqB,CAAC,WAAW;KAC7C;IACD;QACE,UAAU,EAAE,uBAAuB;QACnC,OAAO,EAAE,QAAQ;QACjB,MAAM,EAAE,iBAAiB;QACzB,OAAO,EAAE,EAAE,YAAY,EAAE,CAAC,6BAA6B,CAAC,EAAE;KAC3D;CACyC,CAAC;AAE7C,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,EAAE,EAAE,OAAO;IACX,UAAU,EAAE,UAAU;IACtB,KAAK,EAAE,UAAU;IACjB,SAAS,EAAE,cAAc;IACzB,oBAAoB,EAAE,yBAAyB;IAC/C,OAAO,EAAE,YAAY;CACH,CAAC"}

package/dist/flows/sweep/flow.d.ts

@@ -0,0 +1,2 @@
+export declare const sweepFlowDefinition: import("../flow-definition.js").FlowDefinition;
+//# sourceMappingURL=flow.d.ts.map

package/dist/flows/sweep/flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/flows/sweep/flow.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,gDAAgC,CAAC"}

package/dist/flows/sweep/flow.js

@@ -0,0 +1,4 @@
+import { defineFlowData } from '../flow-definition.js';
+import { sweepFlowData } from './data.js';
+export const sweepFlowDefinition = defineFlowData(sweepFlowData);
+//# sourceMappingURL=flow.js.map

package/dist/flows/sweep/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../../src/flows/sweep/flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,MAAM,CAAC,MAAM,mBAAmB,GAAG,cAAc,CAAC,aAAa,CAAC,CAAC"}

package/dist/flows/sweep/paths.d.ts

@@ -0,0 +1,11 @@
+export declare const SWEEP_CENSUS_REPORT_PATH = "reports/sweep/census.json";
+export declare const SWEEP_PARTITION_REPORT_PATH = "reports/sweep/partition.json";
+export declare const SWEEP_WAVE_AGGREGATE_PATH = "reports/sweep/wave-aggregate.json";
+export declare const SWEEP_WAVE_BRANCHES_DIR = "reports/sweep/wave-branches";
+export declare const SWEEP_RESCAN_REPORT_PATH = "reports/sweep/rescan.json";
+export declare const SWEEP_CARRIED_NOTES_PATH = "reports/sweep/carried-notes.json";
+export declare const SWEEP_JUDGE_REQUEST_PATH = "reports/sweep/judgment.request.json";
+export declare const SWEEP_JUDGE_RECEIPT_PATH = "reports/sweep/judgment.receipt.txt";
+export declare const SWEEP_JUDGE_RESULT_PATH = "reports/sweep/judgment.result.json";
+export declare const SWEEP_JUDGE_REPORT_PATH = "reports/sweep/judgment.report.json";
+//# sourceMappingURL=paths.d.ts.map

package/dist/flows/sweep/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/flows/sweep/paths.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,wBAAwB,8BAA8B,CAAC;AACpE,eAAO,MAAM,2BAA2B,iCAAiC,CAAC;AAC1E,eAAO,MAAM,yBAAyB,sCAAsC,CAAC;AAC7E,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AACrE,eAAO,MAAM,wBAAwB,8BAA8B,CAAC;AACpE,eAAO,MAAM,wBAAwB,qCAAqC,CAAC;AAC3E,eAAO,MAAM,wBAAwB,wCAAwC,CAAC;AAC9E,eAAO,MAAM,wBAAwB,uCAAuC,CAAC;AAC7E,eAAO,MAAM,uBAAuB,uCAAuC,CAAC;AAC5E,eAAO,MAAM,uBAAuB,uCAAuC,CAAC"}