dorfl 0.0.0 → 0.1.0

package/dist/select-priority.d.ts

@@ -0,0 +1,188 @@
+import { type SelectCaps } from './select.js';
+import type { ScanReport } from './scan.js';
+import { type HumanOnlyGate } from './tasking-eligibility.js';
+import { type SelectionOrderConfig } from './select-order.js';
+/**
+ * The SHARED, PURE selection-and-ordering helper for the multi-item `do`/`advance`
+ * forms (auto-pick / `-n <x>` / `<a> <b> …`) and the CONFIGURABLE selection ORDER
+ * (task `advance-selection-order-config`; ADR `ci-config-policy-and-gate-family`,
+ * selection-order section). `apply` is PINNED FIRST (consume-always-wins); the
+ * other four pools (`build` / `task` / `surface` / `triage`) are ranked by the
+ * per-repo `selectionOrder` field (a PRESET keyword or an explicit pool-name
+ * list), whose `drain` default reproduces today's tasks-first "drain ready work
+ * before creating more".
+ *
+ * It is the ONE place the cross-pool ordering lives, so it is not duplicated when
+ * `run`'s tick later adopts the SAME priority
+ * (ADR §3: "the `run`/`do` auto-task step"). This task (`do-autopick`) OWNS and
+ * builds this helper; it does NOT retro-wire `run` to call it (at `do-autopick`
+ * time `run`'s tick is task-only — concurrent + looped — and adopting this
+ * helper, so `run` also auto-tasks eligible prds, is a noted FOLLOW-UP once both
+ * land). Build it standalone; do not assume `run` already calls it.
+ *
+ * **Up to FIVE pools.** The `scan`/`selectCandidates`/eligibility model is
+ * TASK-ONLY (there is no prd candidate). So this helper composes:
+ *
+ *   - the **`build` pool** (eligible TASKS) — the EXISTING {@link selectCandidates}
+ *     path (round-robin across repos, capped). This is the EXACT task-selection
+ *     primitive `run` uses, so `run` and this helper SHARE it (they share
+ *     `selectCandidates`, the task-pool core).
+ *   - the **`task` pool** (prd-to-task) — a pool the caller builds from the prd reader
+ *     (`ledgerRead.resolveSpecPool`) filtered by `autoslice-gate`'s pure predicate
+ *     ({@link resolveTaskingEligibility}); see {@link taskableSpecs}. The helper
+ *     does NOT reinvent prd eligibility.
+ *
+ * `do` is STRICTLY SEQUENTIAL (parallelism is `run`'s job, ADR §3) — this helper
+ * only ORDERS + COUNTS the items; the caller runs the existing `do` pipeline per
+ * item one at a time. `count` bounds how many items are taken (auto-pick = 1,
+ * `-n <x>` = x). It is NOT a parallelism knob.
+ */
+/**
+ * Which namespace a selected item names (mirrors the slug-namespace split). The
+ * `do` selection only ever produces `task`/`prd`; the `advance` selection ALSO
+ * produces `observation` (the lifecycle triage pool, task
+ * `advance-autopick-lifecycle-pools`), so a selected lifecycle item carries which
+ * rung the driver dispatches to. The widening is BACKWARD-COMPATIBLE: `do` never
+ * emits `observation` (its lifecycle pools default to none, see
+ * {@link selectPrioritised}).
+ */
+export type SelectedNamespace = 'task' | 'spec' | 'observation';
+/** One item the selection layer picked, in run order. */
+export interface SelectedItem {
+    /** The repo this item lives in (a working checkout for in-place `do`). */
+    repoPath: string;
+    /** The bare slug to act on. */
+    slug: string;
+    /**
+     * `'task'` ⇒ run the task-build `do` pipeline; `'spec'` ⇒ dispatch to the
+     * `do spec:<slug>` tasking path (tasking itself is `autoslice-command`, not
+     * here); `'observation'` ⇒ (advance only) the triage rung via `obs:<slug>`. The
+     * caller turns this into the right `do`/`advance` arg/dispatch.
+     */
+    namespace: SelectedNamespace;
+}
+/**
+ * A lifecycle-pool selected item (task `advance-autopick-lifecycle-pools`). It is
+ * a {@link SelectedItem} — the same shape — carrying the lifecycle namespace
+ * (`observation` for triage; `task`/`prd` for a `needsAnswers`-blocked item the
+ * tick will surface/apply). A distinct alias names the lifecycle pools at the
+ * call sites WITHOUT a structural difference (the discriminator is `namespace`).
+ */
+export type LifecycleSelectedItem = SelectedItem;
+/** A prd candidate for the tasking pool, before the eligibility gate runs. */
+export interface SpecCandidate {
+    repoPath: string;
+    slug: string;
+    humanOnly: HumanOnlyGate;
+    needsAnswers: HumanOnlyGate;
+    taskedAfter: string[];
+}
+/** Inputs to {@link taskableSpecs}: the raw prd pool + the gate context. */
+export interface TaskableSpecsInput {
+    /** Every prd enumerated from `work/prds/ready/` (the auto-task candidate source). */
+    candidates: SpecCandidate[];
+    /** Slugs whose prd resides in `work/prds/tasked/` (resolves `taskedAfter`). */
+    taskedSlugs: Set<string>;
+    /** The repo's resolved `autoTask` policy (`autoslice-gate`'s per-repo key). */
+    autoTask: boolean;
+}
+/**
+ * Filter a raw prd pool down to the TASKABLE prds, in declaration order, using
+ * `autoslice-gate`'s pure predicate ({@link resolveTaskingEligibility}) — NOT a
+ * reinvented eligibility model. A prd is taskable iff `needsAnswers !== true &&
+ * humanOnly !== true && autoTask` AND every `taskedAfter` prd is already tasked.
+ * Pure: no I/O (the caller reads the pool through `ledgerRead.resolveSpecPool`).
+ */
+export declare function taskableSpecs(input: TaskableSpecsInput): SpecCandidate[];
+/** Inputs to {@link selectPrioritised}: the pools + ordering + count. */
+export interface SelectPrioritisedInput {
+    /**
+     * The task pool source — a `scan` report (task-only, the existing model) +
+     * the concurrency/selection caps. The helper runs the EXISTING
+     * {@link selectCandidates} over it, so the task ordering is byte-identical to
+     * what `run` selects (the shared primitive).
+     */
+    report: ScanReport;
+    /** Caps for the task-pool selection (round-robin/per-repo/total). */
+    caps: SelectCaps;
+    /**
+     * The ALREADY-FILTERED taskable spec pool (run {@link taskableSpecs} first).
+     * In declaration order; this helper does not re-gate them.
+     */
+    specs: SpecCandidate[];
+    /**
+     * The configurable selection ORDER across the four ORDERABLE pools (`build` /
+     * `task` / `surface` / `triage`), as a PRESET keyword or an explicit pool-name
+     * list (task `advance-selection-order-config`; the `selectionOrder` config
+     * field). Resolved through {@link resolveSelectionOrder} (apply is pinned first
+     * and NOT nameable here). OMITTED ⇒ the `drain` default (`[build, task,
+     * surface, triage]`), which reproduces today's tasks-first "drain before
+     * create" two-pool default. `[task, build, ...]` reproduces the old
+     * `prdsFirst: true`. An unknown name/keyword FAILS LOUDLY.
+     */
+    selectionOrder?: SelectionOrderConfig;
+    /**
+     * How many items to take across ALL pools, in priority order. Auto-pick = 1;
+     * `do -n <x>` = x. Unset ⇒ take ALL eligible items (the priority order is still
+     * applied). Sequential — NOT a parallelism knob.
+     */
+    count?: number;
+    /**
+     * The OPTIONAL lifecycle pools (task `advance-autopick-lifecycle-pools`),
+     * constructed CALLER-SIDE (the `advance` callers only) and passed in — exactly
+     * as {@link prds} is. DEFAULTS to none, so `performDoAuto` (which passes only
+     * its two pools) is provably UNCHANGED: `do` auto-pick never selects an
+     * observation or a `needsAnswers` item. ONLY the `advance` callers
+     * (`performAdvanceAuto` / the mirror-side advance path) supply these.
+     *
+     * Ordered per the resolved {@link selectionOrder}: `apply` is ALWAYS prepended
+     * (pinned first — consume-always-wins), then the four orderable pools (`build` /
+     * `task` / `surface` / `triage`) in the configured order, truncated to
+     * {@link count}. A pool NAMED in the order but absent here (gated off — empty)
+     * is simply a no-op (it contributes no items), so the gates (what is PRESENT)
+     * and `selectionOrder` (what runs first) compose ORTHOGONALLY.
+     */
+    lifecycle?: SelectedLifecyclePools;
+    /**
+     * The HELD-SLUG set to SUBTRACT from the `build` pool (eligible TASKS) — prd
+     * `ledger-status-per-item-lock-refs` US #15, task
+     * `claim-acquires-unified-lock-no-body-move`. A task whose per-item lock is
+     * currently held is dropped from selection, so the eligible pool is "in
+     * `backlog/` on `main` AND no lock held". Normally the `report` is already
+     * subtracted at {@link scoreItems} time (the readers gather held locks), so this
+     * is a SECOND, explicit guard for callers that build the report WITHOUT the
+     * subtraction; OMITTED ⇒ no extra filtering. Redundant-but-harmless while the
+     * body still moves to `in-progress/`; in force for task #9.
+     */
+    heldSlugs?: Set<string>;
+}
+/** The (optional) lifecycle pools handed to {@link selectPrioritised}, pre-built. */
+export interface SelectedLifecyclePools {
+    /** `apply` items (answered sidecars; CONSUME, always present when supplied). */
+    apply: LifecycleSelectedItem[];
+    /** `surface` items (blocked, no all-answered sidecar; already gate-filtered). */
+    surface: LifecycleSelectedItem[];
+    /** `triage` items (untriaged observations; already gate-filtered). */
+    triage: LifecycleSelectedItem[];
+}
+/**
+ * Build the ordered, counted list of items to do across the (up to) FIVE pools,
+ * applying the configurable {@link selectionOrder} with `apply` PINNED FIRST and
+ * the count bound. The task pool is selected via the EXISTING
+ * {@link selectCandidates} (the shared primitive `run` uses); the prd pool is the
+ * pre-filtered {@link taskableSpecs} output; the lifecycle pools (`apply` /
+ * `surface` / `triage`) are caller-built (none for `do`).
+ *
+ * Ordering: `apply` is always prepended (consume-always-wins; not orderable),
+ * then the four orderable pools (`build` = eligible tasks, `task` = taskable
+ * prds, `surface`, `triage`) interleaved in the resolved {@link selectionOrder}
+ * (default `drain` = `[build, task, surface, triage]`, which reproduces today's
+ * tasks-first two-pool default). A pool named in the order but EMPTY (gated off)
+ * contributes nothing — a no-op, not an error (gates decide what is PRESENT,
+ * `selectionOrder` ranks what is present). Then truncated to `count`.
+ *
+ * Deterministic + pure. The caller runs the existing `do` pipeline per returned
+ * item, SEQUENTIALLY.
+ */
+export declare function selectPrioritised(input: SelectPrioritisedInput): SelectedItem[];
+//# sourceMappingURL=select-priority.d.ts.map

package/dist/select-priority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-priority.d.ts","sourceRoot":"","sources":["../src/select-priority.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,UAAU,EAAC,MAAM,aAAa,CAAC;AAC9E,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAC1C,OAAO,EAEN,KAAK,aAAa,EAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAIN,KAAK,oBAAoB,EACzB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC;AAEhE,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC5B,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,SAAS,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,YAAY,CAAC;AAEjD,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,aAAa,CAAC;IACzB,YAAY,EAAE,aAAa,CAAC;IAC5B,WAAW,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IAClC,qFAAqF;IACrF,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,+EAA+E;IAC/E,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,+EAA+E;IAC/E,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,EAAE,CAWxE;AAED,yEAAyE;AACzE,MAAM,WAAW,sBAAsB;IACtC;;;;;OAKG;IACH,MAAM,EAAE,UAAU,CAAC;IACnB,qEAAqE;IACrE,IAAI,EAAE,UAAU,CAAC;IACjB;;;OAGG;IACH,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACxB;AAED,qFAAqF;AACrF,MAAM,WAAW,sBAAsB;IACtC,gFAAgF;IAChF,KAAK,EAAE,qBAAqB,EAAE,CAAC;IAC/B,iFAAiF;IACjF,OAAO,EAAE,qBAAqB,EAAE,CAAC;IACjC,sEAAsE;IACtE,MAAM,EAAE,qBAAqB,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,sBAAsB,GAC3B,YAAY,EAAE,CAgDhB"}

package/dist/select-priority.js

@@ -0,0 +1,80 @@
+import { selectCandidates } from './select.js';
+import { resolveTaskingEligibility, } from './tasking-eligibility.js';
+import { resolveSelectionOrder, DEFAULT_SELECTION_ORDER, } from './select-order.js';
+/**
+ * Filter a raw prd pool down to the TASKABLE prds, in declaration order, using
+ * `autoslice-gate`'s pure predicate ({@link resolveTaskingEligibility}) — NOT a
+ * reinvented eligibility model. A prd is taskable iff `needsAnswers !== true &&
+ * humanOnly !== true && autoTask` AND every `taskedAfter` prd is already tasked.
+ * Pure: no I/O (the caller reads the pool through `ledgerRead.resolveSpecPool`).
+ */
+export function taskableSpecs(input) {
+    return input.candidates.filter((spec) => resolveTaskingEligibility({
+        humanOnly: spec.humanOnly,
+        needsAnswers: spec.needsAnswers,
+        taskedAfter: spec.taskedAfter,
+        taskedSlugs: input.taskedSlugs,
+        autoTask: input.autoTask,
+    }).taskable);
+}
+/**
+ * Build the ordered, counted list of items to do across the (up to) FIVE pools,
+ * applying the configurable {@link selectionOrder} with `apply` PINNED FIRST and
+ * the count bound. The task pool is selected via the EXISTING
+ * {@link selectCandidates} (the shared primitive `run` uses); the prd pool is the
+ * pre-filtered {@link taskableSpecs} output; the lifecycle pools (`apply` /
+ * `surface` / `triage`) are caller-built (none for `do`).
+ *
+ * Ordering: `apply` is always prepended (consume-always-wins; not orderable),
+ * then the four orderable pools (`build` = eligible tasks, `task` = taskable
+ * prds, `surface`, `triage`) interleaved in the resolved {@link selectionOrder}
+ * (default `drain` = `[build, task, surface, triage]`, which reproduces today's
+ * tasks-first two-pool default). A pool named in the order but EMPTY (gated off)
+ * contributes nothing — a no-op, not an error (gates decide what is PRESENT,
+ * `selectionOrder` ranks what is present). Then truncated to `count`.
+ *
+ * Deterministic + pure. The caller runs the existing `do` pipeline per returned
+ * item, SEQUENTIALLY.
+ */
+export function selectPrioritised(input) {
+    const held = input.heldSlugs;
+    const buildItems = selectCandidates(input.report, input.caps)
+        .filter((candidate) => !held || !held.has(candidate.slug))
+        .map((candidate) => ({
+        repoPath: candidate.repoPath,
+        slug: candidate.slug,
+        namespace: 'task',
+    }));
+    const taskItems = input.specs.map((spec) => ({
+        repoPath: spec.repoPath,
+        slug: spec.slug,
+        namespace: 'spec',
+    }));
+    const lifecycle = input.lifecycle;
+    // The per-pool item lists, keyed by the orderable pool name. NOTE the
+    // vocabulary bridge: `build` = the eligible-TASK pool (namespace `task`),
+    // `task` = the taskable-prd pool (namespace `prd`) — the action names, not the
+    // item namespaces (task `advance-selection-order-config`).
+    const byPool = {
+        build: buildItems,
+        task: taskItems,
+        surface: lifecycle?.surface ?? [],
+        triage: lifecycle?.triage ?? [],
+    };
+    // Resolve the configured order (preset or explicit list; unknown name/keyword
+    // FAILS LOUDLY here). OMITTED ⇒ the `drain` default.
+    const order = resolveSelectionOrder(input.selectionOrder ?? DEFAULT_SELECTION_ORDER);
+    // `apply` is ALWAYS first (pinned, not orderable), then the four orderable
+    // pools in the resolved order. An absent (gated-off) pool's list is empty, so it
+    // drops out cleanly — no special-casing.
+    const applyItems = lifecycle?.apply ?? [];
+    const ordered = [
+        ...applyItems,
+        ...order.flatMap((pool) => byPool[pool]),
+    ];
+    if (input.count === undefined) {
+        return ordered;
+    }
+    return ordered.slice(0, Math.max(0, input.count));
+}
+//# sourceMappingURL=select-priority.js.map

package/dist/select-priority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-priority.js","sourceRoot":"","sources":["../src/select-priority.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAkC,MAAM,aAAa,CAAC;AAE9E,OAAO,EACN,yBAAyB,GAEzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACN,qBAAqB,EACrB,uBAAuB,GAGvB,MAAM,mBAAmB,CAAC;AA4F3B;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,KAAyB;IACtD,OAAO,KAAK,CAAC,UAAU,CAAC,MAAM,CAC7B,CAAC,IAAI,EAAE,EAAE,CACR,yBAAyB,CAAC;QACzB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ;KACxB,CAAC,CAAC,QAAQ,CACZ,CAAC;AACH,CAAC;AA2ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAChC,KAA6B;IAE7B,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC;IAC7B,MAAM,UAAU,GAAmB,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;SAC3E,MAAM,CAAC,CAAC,SAAoB,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SACpE,GAAG,CAAC,CAAC,SAAoB,EAAE,EAAE,CAAC,CAAC;QAC/B,QAAQ,EAAE,SAAS,CAAC,QAAQ;QAC5B,IAAI,EAAE,SAAS,CAAC,IAAI;QACpB,SAAS,EAAE,MAAe;KAC1B,CAAC,CAAC,CAAC;IAEL,MAAM,SAAS,GAAmB,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC5D,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,SAAS,EAAE,MAAe;KAC1B,CAAC,CAAC,CAAC;IAEJ,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAElC,sEAAsE;IACtE,0EAA0E;IAC1E,+EAA+E;IAC/E,2DAA2D;IAC3D,MAAM,MAAM,GAA0C;QACrD,KAAK,EAAE,UAAU;QACjB,IAAI,EAAE,SAAS;QACf,OAAO,EAAE,SAAS,EAAE,OAAO,IAAI,EAAE;QACjC,MAAM,EAAE,SAAS,EAAE,MAAM,IAAI,EAAE;KAC/B,CAAC;IAEF,8EAA8E;IAC9E,qDAAqD;IACrD,MAAM,KAAK,GAAG,qBAAqB,CAClC,KAAK,CAAC,cAAc,IAAI,uBAAuB,CAC/C,CAAC;IAEF,2EAA2E;IAC3E,iFAAiF;IACjF,yCAAyC;IACzC,MAAM,UAAU,GAAG,SAAS,EAAE,KAAK,IAAI,EAAE,CAAC;IAC1C,MAAM,OAAO,GAAmB;QAC/B,GAAG,UAAU;QACb,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KACxC,CAAC;IAEF,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,OAAO,CAAC;IAChB,CAAC;IACD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACnD,CAAC"}

package/dist/select.d.ts

@@ -0,0 +1,25 @@
+import type { ScanReport } from './scan.js';
+/** One item the runner intends to claim+run, identified by repo + slug. */
+export interface Candidate {
+    repoPath: string;
+    slug: string;
+}
+export interface SelectCaps {
+    /** Global cap on items claimed+run in one tick. */
+    maxParallel: number;
+    /** Per-repo cap on concurrent claims. */
+    perRepoMax: number;
+}
+/**
+ * Build the ordered list of candidates to attempt from a `scan` report,
+ * respecting the concurrency caps. Only eligible items are considered. Selection
+ * is round-robin across repos for fairness (so a single busy repo cannot starve
+ * the others under `maxParallel`), capping each repo at `perRepoMax` and the
+ * total at `maxParallel`. Deterministic: repos and items are already sorted by
+ * the scan core.
+ *
+ * NOTE: this is optimistic selection only — actual ownership is decided by the
+ * arbiter when the claim CAS runs. A candidate that loses the race is dropped then.
+ */
+export declare function selectCandidates(report: ScanReport, caps: SelectCaps): Candidate[];
+//# sourceMappingURL=select.d.ts.map

package/dist/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../src/select.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1C,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,UAAU;IAC1B,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,GACd,SAAS,EAAE,CAgCb"}

package/dist/select.js

@@ -0,0 +1,43 @@
+/**
+ * Build the ordered list of candidates to attempt from a `scan` report,
+ * respecting the concurrency caps. Only eligible items are considered. Selection
+ * is round-robin across repos for fairness (so a single busy repo cannot starve
+ * the others under `maxParallel`), capping each repo at `perRepoMax` and the
+ * total at `maxParallel`. Deterministic: repos and items are already sorted by
+ * the scan core.
+ *
+ * NOTE: this is optimistic selection only — actual ownership is decided by the
+ * arbiter when the claim CAS runs. A candidate that loses the race is dropped then.
+ */
+export function selectCandidates(report, caps) {
+    // Per-repo queues of eligible slugs, preserving scan order.
+    const queues = report.repos.map((repo) => ({
+        path: repo.path,
+        slugs: repo.items
+            .filter((item) => item.eligibility.eligible)
+            .map((item) => item.slug),
+        taken: 0,
+    }));
+    const picks = [];
+    let progress = true;
+    while (picks.length < caps.maxParallel && progress) {
+        progress = false;
+        for (const queue of queues) {
+            if (picks.length >= caps.maxParallel) {
+                break;
+            }
+            if (queue.taken >= caps.perRepoMax) {
+                continue;
+            }
+            const next = queue.slugs[queue.taken];
+            if (next === undefined) {
+                continue;
+            }
+            picks.push({ repoPath: queue.path, slug: next });
+            queue.taken++;
+            progress = true;
+        }
+    }
+    return picks;
+}
+//# sourceMappingURL=select.js.map

package/dist/select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.js","sourceRoot":"","sources":["../src/select.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAC/B,MAAkB,EAClB,IAAgB;IAEhB,4DAA4D;IAC5D,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC1C,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,KAAK,EAAE,IAAI,CAAC,KAAK;aACf,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;aAC3C,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;QAC1B,KAAK,EAAE,CAAC;KACR,CAAC,CAAC,CAAC;IAEJ,MAAM,KAAK,GAAgB,EAAE,CAAC;IAC9B,IAAI,QAAQ,GAAG,IAAI,CAAC;IACpB,OAAO,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,IAAI,QAAQ,EAAE,CAAC;QACpD,QAAQ,GAAG,KAAK,CAAC;QACjB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC5B,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACtC,MAAM;YACP,CAAC;YACD,IAAI,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpC,SAAS;YACV,CAAC;YACD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACxB,SAAS;YACV,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,EAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,QAAQ,GAAG,IAAI,CAAC;QACjB,CAAC;IACF,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/session-path.d.ts

@@ -0,0 +1,36 @@
+/**
+ * pi's DEFAULT per-cwd sessions folder for `cwd` — a direct child of
+ * `~/.pi/agent/sessions/` (invariant #4), so the dashboard's non-recursive
+ * `listAll()` scans it and groups by the session header `cwd`. Replicates pi's
+ * `getDefaultSessionDirPath` encoding verbatim (verified vs pinned source). PURE
+ * (does not create the folder — the parent is ensured at generation time / by
+ * pi's own `SessionManager.open`).
+ */
+export declare function piDefaultSessionDir(cwd: string): string;
+/** Inputs to {@link generateSessionPath}. */
+export interface GenerateSessionPathInput {
+    /**
+     * The HOST-ONLY sessions root (resolved `config.sessionsDir`). `undefined`
+     * (unset) ⇒ pi's default per-cwd folder for {@link cwd} (the DYNAMIC default,
+     * kept in this ONE place — never smeared across config defaulting).
+     */
+    sessionsDir?: string;
+    /** The job cwd pi is spawned in — used for the unset-default folder. */
+    cwd: string;
+    /**
+     * A human-readable id for the filename stem (the slug in-place, the work-id
+     * for a job worktree). Made unique per launch internally.
+     */
+    id: string;
+}
+/**
+ * Generate the absolute, `.jsonl`-ending session FILE path to pass as
+ * `--session <path>` (invariant #1). `<root>/<id>-<unique>.jsonl`, where `<root>`
+ * is the resolved `sessionsDir` or — when unset — pi's default per-cwd folder
+ * (the DYNAMIC default). The path is ABSOLUTE (resolved against the process cwd
+ * if a relative `sessionsDir` was given) and the stem is unique per launch, so a
+ * second launch in the same checkout never appends to / replays the first's
+ * session.
+ */
+export declare function generateSessionPath(input: GenerateSessionPathInput): string;
+//# sourceMappingURL=session-path.d.ts.map

package/dist/session-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-path.d.ts","sourceRoot":"","sources":["../src/session-path.ts"],"names":[],"mappings":"AA8FA;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIvD;AAcD,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACxC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,MAAM,CAM3E"}

package/dist/session-path.js

@@ -0,0 +1,129 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+/**
+ * pi's env override for its agent dir. Real pi reads
+ * `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR` (i.e. `PI_CODING_AGENT_DIR`) in its
+ * `getAgentDir()` (verified vs pinned source `config.ts`); when set, ALL of pi's
+ * default session paths move under it. dorfl's replica MUST honour the same
+ * var, or a user/CI that points pi at a custom agent dir would have dorfl
+ * write sessions to `~/.pi/agent/sessions` while pi reads the custom dir — sessions
+ * then invisible to pi AND pi-remote (the very breakage this task fixes). Also the
+ * clean lever for test isolation (point it at a scratch dir). NOTE: we honour only
+ * the agent-dir var, not pi's separate `PI_CODING_AGENT_SESSION_DIR` — dorfl
+ * already has its own `sessionsDir` override for that role.
+ */
+const PI_AGENT_DIR_ENV = 'PI_CODING_AGENT_DIR';
+/** Expand a leading `~`/`~/` to the home dir (pi's `expandTildePath` behaviour). */
+function expandTilde(p) {
+    if (p === '~') {
+        return homedir();
+    }
+    if (p.startsWith('~/') || p.startsWith('~\\')) {
+        return join(homedir(), p.slice(2));
+    }
+    return p;
+}
+/**
+ * Generate the **full pi session-file path** the harness passes as `--session
+ * <path>` (task `session-path-pi-default`). This is the single source of the
+ * session path: the caller generates it ONCE (before pi launches, so the
+ * `do --watch` tailer can tail the KNOWN path) and threads it into BOTH the
+ * adapter (`LaunchInput.session`) and the tailer.
+ *
+ * ## Why a full FILE path, not `--session-dir`
+ *
+ * dorfl used to pin `--session-dir <cwd>/.dorfl-pi-session`, which
+ * (1) hid sessions from the pi-remote dashboard (`SessionManager.listAll()` only
+ * scans `~/.pi/agent/sessions/`), (2) made `do --watch` race onto a stale
+ * prior-run log (newest-by-mtime in a shared dir), and (3) polluted the in-place
+ * checkout with an untracked dir. Passing `--session <full-path>` fixes all
+ * three: pi creates+writes the session at exactly that path, it takes precedence
+ * over `--session-dir`, and the watcher tails a path it knew before pi started.
+ *
+ * ## The four load-bearing pi `--session` invariants (verified vs pinned pi
+ * source `core/session-manager.ts` + `main.ts` `resolveSessionPath`)
+ *
+ *  1. **The arg MUST be PATH-SHAPED — absolute and ending `.jsonl`.** pi's
+ *     `resolveSessionPath` takes the file-path branch ONLY when the arg contains
+ *     a slash OR ends `.jsonl`; otherwise it treats the arg as a session-ID to
+ *     look up, fails `not_found`, and pi EXITS 1. So `<sessionsDir>/<id>.jsonl`
+ *     is required (a bare id would kill the run).
+ *  2. **pi creates+writes a NON-EXISTENT `--session` path** (`SessionManager.open`
+ *     on a missing file → `newSession()` pinned to the path). So the FILENAME
+ *     must be UNIQUE PER LAUNCH: a reused name on an existing non-empty file would
+ *     make pi LOAD + APPEND (resume), silently replaying the prior run.
+ *  3. **The header `cwd` falls back to `process.cwd()` for a new file** (no header
+ *     to read), so dashboard repo-grouping is correct ONLY because the adapter
+ *     spawns pi with `cwd: input.dir`. The FOLDER does not imply the repo.
+ *  4. **`listAll` is NON-RECURSIVE (one level):** a session is dashboard-visible
+ *     via the default `listAll()` ONLY as a `.jsonl` DIRECTLY inside a first-level
+ *     subdir of `~/.pi/agent/sessions/` — which the default {@link
+ *     piDefaultSessionDir} (a direct child) gives.
+ *
+ * ## Why the slug helper is replicated, not imported
+ *
+ * dorfl depends ONLY on `commander` (see
+ * `work/notes/observations/task-premise-pi-coding-agent-not-a-dep.md`). pi's exported
+ * `getDefaultSessionDir(cwd)` lives in `@earendil-works/pi-coding-agent`, whose
+ * dependency tree is heavy (`pi-agent-core`, `pi-ai`, `zod`, `ws`). Pulling that
+ * in for one tiny slug function is not worth it, so the encoding is REPLICATED
+ * here (the same choice the do-watch task made for its session-log type). The
+ * encoding is verified verbatim against pinned pi source `getDefaultSessionDirPath`:
+ *
+ *   join(agentDir, 'sessions', `--${resolve(cwd).replace(/^[/\\]/,'').replace(/[/\\:]/g,'-')}--`)
+ *
+ * where `agentDir` is `~/.pi/agent`. If a runtime dep on pi-coding-agent is ever
+ * wanted, swapping this for the import is a one-line change.
+ */
+/**
+ * pi's agent dir — the parent of `sessions/`. Honours `PI_CODING_AGENT_DIR`
+ * (matching real pi's `getAgentDir()`), else `~/.pi/agent`. Read at call time (not
+ * cached) so a test setting `process.env.PI_CODING_AGENT_DIR` is respected.
+ */
+function piAgentDir() {
+    const override = process.env[PI_AGENT_DIR_ENV];
+    if (override !== undefined && override !== '') {
+        return expandTilde(override);
+    }
+    return join(homedir(), '.pi', 'agent');
+}
+/**
+ * pi's DEFAULT per-cwd sessions folder for `cwd` — a direct child of
+ * `~/.pi/agent/sessions/` (invariant #4), so the dashboard's non-recursive
+ * `listAll()` scans it and groups by the session header `cwd`. Replicates pi's
+ * `getDefaultSessionDirPath` encoding verbatim (verified vs pinned source). PURE
+ * (does not create the folder — the parent is ensured at generation time / by
+ * pi's own `SessionManager.open`).
+ */
+export function piDefaultSessionDir(cwd) {
+    const resolvedCwd = resolve(cwd);
+    const safe = `--${resolvedCwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+    return join(piAgentDir(), 'sessions', safe);
+}
+/**
+ * Build a filename STEM that is UNIQUE PER LAUNCH (invariant #2). The `id`
+ * (slug for in-place, work-id for job-worktree) is the human-readable anchor; a
+ * timestamp + a short random suffix make it collision-proof even for two
+ * launches in the same millisecond / same checkout reusing the same slug.
+ */
+function uniqueStem(id) {
+    const ts = Date.now().toString(36);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${id}-${ts}-${rand}`;
+}
+/**
+ * Generate the absolute, `.jsonl`-ending session FILE path to pass as
+ * `--session <path>` (invariant #1). `<root>/<id>-<unique>.jsonl`, where `<root>`
+ * is the resolved `sessionsDir` or — when unset — pi's default per-cwd folder
+ * (the DYNAMIC default). The path is ABSOLUTE (resolved against the process cwd
+ * if a relative `sessionsDir` was given) and the stem is unique per launch, so a
+ * second launch in the same checkout never appends to / replays the first's
+ * session.
+ */
+export function generateSessionPath(input) {
+    const root = input.sessionsDir !== undefined && input.sessionsDir !== ''
+        ? resolve(input.sessionsDir)
+        : piDefaultSessionDir(input.cwd);
+    return join(root, `${uniqueStem(input.id)}.jsonl`);
+}
+//# sourceMappingURL=session-path.js.map

package/dist/session-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-path.js","sourceRoot":"","sources":["../src/session-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,MAAM,SAAS,CAAC;AAChC,OAAO,EAAC,IAAI,EAAE,OAAO,EAAC,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AAE/C,oFAAoF;AACpF,SAAS,WAAW,CAAC,CAAS;IAC7B,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QACf,OAAO,OAAO,EAAE,CAAC;IAClB,CAAC;IACD,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/C,OAAO,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,CAAC,CAAC;AACV,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH;;;;GAIG;AACH,SAAS,UAAU;IAClB,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAC/C,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QAC/C,OAAO,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAW;IAC9C,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,IAAI,GAAG,KAAK,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC;IAChF,OAAO,IAAI,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,EAAU;IAC7B,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACnC,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpD,OAAO,GAAG,EAAE,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;AAC9B,CAAC;AAmBD;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAA+B;IAClE,MAAM,IAAI,GACT,KAAK,CAAC,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,WAAW,KAAK,EAAE;QAC1D,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC;QAC5B,CAAC,CAAC,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACnC,OAAO,IAAI,CAAC,IAAI,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;AACpD,CAAC"}

package/dist/sidecar-apply.d.ts

@@ -0,0 +1,83 @@
+import { type SidecarModel } from './sidecar.js';
+/**
+ * The ATOMIC APPLY — the keystone the advance state-machine invariant
+ * `needsAnswers:false ⟺ no active sidecar` rests on. It mutates the item BODY
+ * and the SIDECAR in ONE commit, so the human never sees a torn "answer applied
+ * but sidecar still open" (a re-ask) or its reverse.
+ *
+ * Two shapes, both ONE commit:
+ *
+ *   - **append / re-pause** (the sidecar is NOT fully answered after this apply):
+ *     write the updated item body (if any) and the updated sidecar, leaving
+ *     `needsAnswers: true`. The sidecar stays present (still carries pending
+ *     questions).
+ *   - **full resolution** (every entry answered): write the updated item body,
+ *     CLEAR `needsAnswers` (→ `false`) on the item, and DELETE the sidecar — all
+ *     in the SAME commit. After this the invariant holds: `needsAnswers:false`
+ *     and no sidecar file.
+ *
+ * This task delivers the single-commit primitive over a working tree (the
+ * throwaway-git-repo pattern the tasking-lock / claim-cas tests use). It does
+ * NOT take the `advancing` CAS lock or race the arbiter — that is the lock
+ * task's job; this is the contract the lock later wraps. The caller supplies
+ * the item's CURRENT body and its on-disk PATH (relative to the repo root); the
+ * apply rewrites that file + the sidecar and commits them together.
+ */
+/** Whether to leave the sidecar present (re-pause) or delete it (resolved). */
+export type ApplyMode = 'repause' | 'resolve';
+export interface ApplyAtomicOptions {
+    /** Working clone/worktree the apply commits in. */
+    cwd: string;
+    /**
+     * Item path RELATIVE to `cwd` (e.g. `work/backlog/foo.md`). The sidecar path
+     * is derived from the model's identity — NOT from this path — so it survives
+     * the item's `git mv`s (identity-keyed, never folder-keyed).
+     */
+    itemPath: string;
+    /**
+     * The NEW item body to write (the apply rung's mutation of the item). When
+     * omitted the item body is left as-is on disk (only `needsAnswers` is touched,
+     * and only on full resolution).
+     */
+    itemBody?: string;
+    /** The sidecar model after this apply (entries updated/appended). */
+    sidecar: SidecarModel;
+    /**
+     * Override the resolution decision. By default it is DERIVED from the model
+     * (`allAnswered(sidecar)` ⇒ resolve, else re-pause) — the source of truth. An
+     * explicit `mode` is for the caller that already classified; it must agree
+     * with the derived state or the apply throws (no torn invariant).
+     */
+    mode?: ApplyMode;
+    /** Advisory committer id for the commit subject. Defaults to git user.name. */
+    by?: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface ApplyAtomicResult {
+    /** `resolved` (sidecar deleted, needsAnswers cleared) or `repaused` (still open). */
+    outcome: 'resolved' | 'repaused';
+    /** The commit sha the apply produced. */
+    commit: string;
+    /** The sidecar path (relative to `cwd`) the apply touched. */
+    sidecarPath: string;
+}
+/** Raised for usage errors (a torn mode, a missing repo). */
+export declare class ApplyAtomicError extends Error {
+    constructor(message: string);
+}
+/**
+ * Apply an answer batch ATOMICALLY: rewrite the item body + the sidecar in ONE
+ * commit, and on full resolution clear `needsAnswers` AND delete the sidecar in
+ * that SAME commit. Returns the produced commit + the outcome.
+ *
+ * The resolution decision is DERIVED from the model (`allAnswered` ⇒ resolve) —
+ * the entries are the source of truth, never the frontmatter mirror. A supplied
+ * {@link ApplyAtomicOptions.mode} must AGREE with that derived state, else the
+ * apply throws (it refuses to publish a torn invariant: a `resolve` that leaves
+ * pending entries, or a `repause` that leaves none).
+ */
+export declare function applyAtomic(options: ApplyAtomicOptions): ApplyAtomicResult;
+//# sourceMappingURL=sidecar-apply.d.ts.map

package/dist/sidecar-apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidecar-apply.d.ts","sourceRoot":"","sources":["../src/sidecar-apply.ts"],"names":[],"mappings":"AAIA,OAAO,EAIN,KAAK,YAAY,EACjB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IAClC,mDAAmD;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,OAAO,EAAE,YAAY,CAAC;IACtB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,+EAA+E;IAC/E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC;IACjC,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,6DAA6D;AAC7D,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI3B;AAiCD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CAgE1E"}