@tacuchi/agent-workflow-cli 21.0.0 → 21.3.0

package/dist/application/flow/advance.js

@@ -0,0 +1,533 @@
+/**
+ * One invocation exhausts every consecutive deterministic step it OWNS.
+ *
+ * The engine walks the journey from where the run left off and applies each
+ * transition that is both the CLI's authority (`cli`) and the CLI's property
+ * (`cli-owned`), one after another, without handing any of them back as work. It
+ * stops at the FIRST transition it cannot apply — a judgment, a preference, an
+ * effect nobody authorized, a blocker — or at the end of the journey, and returns
+ * that boundary as a directive.
+ *
+ * Authority is the axis that decides WHICH boundary: "is this derivable, or does
+ * it need a judgment, a preference, an invocation?". Ownership used to be a second
+ * axis answering "does this CLI decide it yet?", and a row that was derivable but
+ * still doctrine's came back as a `legacy` boundary naming the document about to
+ * decide it. That axis is closed: every row of every public journey is the CLI's,
+ * so ownership no longer routes anything — it fails closed. Both give way to one
+ * thing: an effect nobody authorized stops the advance whoever owns the rule.
+ *
+ * The trace of what it applied lives in the run state, with the authority each
+ * step moved under, so the advance is auditable after the fact instead of being a
+ * claim in a report.
+ *
+ * What "applying" means per transition is the business of each migrated tranche:
+ * here a transition advances the run's position and nothing else. That is why the
+ * registry — not this file — is where a new transition is added.
+ */
+import { DOCS_BOUNDARY, actionOf, alternativesOf, effectsOf, } from "../../domain/flow/authority.js";
+import { authorizeTransition, effectApprovalDigest, } from "../../domain/flow/authorization.js";
+import { PAUSE_LABEL, STOP_LABEL, buildFlowDirective, skippedStepOf, stepOf, } from "../../domain/flow/directive.js";
+import { bindAction, docsBoundaryBreach, skipReason } from "../../domain/flow/rules.js";
+import { MAX_BOUNDARY_ATTEMPTS, applyTransition, attemptsAt, checkAgainstJourney, positionDigest, skipTransition, withBoundary, withPendingAction, } from "../../domain/flow/run-state.js";
+import { buildSemanticRequest, semanticDigest, } from "../semantic-operation/protocol.js";
+import { sessionNumericCode } from "../session-resolver.js";
+export function advanceFlowRun(input) {
+    const incoherent = checkAgainstJourney(input.state, input.journey);
+    if (incoherent !== null)
+        return { ok: false, failure: incoherent };
+    const walked = walk(input.state, input.journey);
+    let state = walked.state;
+    const appliedNow = [...(input.applied ?? []), ...walked.applied];
+    // The boundary and the pending action are written into the state BEFORE its seal
+    // is computed. Resolving first would seal a state that is about to be re-sealed,
+    // and the digest the directive advertises has to be the one the next answer will
+    // be checked against — otherwise every caller that trusted the directive would
+    // be told its answer is stale.
+    const stopped = input.journey[state.applied.length] ?? null;
+    state = withBoundary(state, stopped?.id ?? null);
+    // Only an EMITTED action is pending. Reading it back off the resolved boundary
+    // — instead of off the row — is what keeps the two honest: a delegated step
+    // whose effect is still unapproved stops at the authorization boundary, its
+    // invocation is not in the directive, and the state must not claim the run is
+    // waiting on something nobody was told to run.
+    const emitted = resolveBoundary(state, input.journey).action;
+    state = withPendingAction(state, emitted === null || stopped === null
+        ? null
+        : { transition: stopped.id, digest: actionDigest(emitted) });
+    return directiveFor(state, resolveBoundary(state, input.journey), appliedNow);
+}
+/**
+ * Every consecutive transition the CLI owns AND can apply itself, in one go.
+ *
+ * The walk stops the moment authority changes hands, the moment the next
+ * transition would exercise an effect nobody authorized (advancing automatically
+ * never widens an authorization), the moment it reaches a step whose ownership the
+ * registry does not declare — or the moment the step is delegated.
+ *
+ * The last two stops are the same principle twice. Applying an unowned row would
+ * record as decided-by-the-CLI a step the registry never said it decides; applying
+ * a DELEGATED row would record as done a search, a seeding or a validation that
+ * nothing ran. Both would be the engine claiming something it cannot see, so both
+ * become boundaries: one blocked naming what is missing, the other naming its
+ * invocation and waiting for real output.
+ *
+ * A CONDITIONAL step is the one case that neither applies nor stops: the walk
+ * passes over it, records the omission with its cause, and keeps going whatever
+ * the step's authority would have been. That is checked first on purpose — a
+ * human boundary whose condition did not fire must never be emitted, or the
+ * migrated journey would ask a question the doctrine it replaces does not ask.
+ */
+function walk(from, journey) {
+    let state = from;
+    const applied = [];
+    for (let index = state.applied.length; index < journey.length; index += 1) {
+        const decision = journey[index];
+        if (decision === undefined)
+            break;
+        // A condition that did not fire, or a boundary this run has already tried as
+        // often as it may. Both pass over the step and both say why — the trace has
+        // to distinguish "never happened" from "was given up on".
+        const skipped = skipReason(decision, journey, state.observations) ?? exhaustionSkip(state, decision);
+        if (skipped !== null) {
+            state = skipTransition(state, decision.id);
+            applied.push(skippedStepOf(decision, skipped));
+            continue;
+        }
+        if (decision.authority !== "cli")
+            break;
+        if (!owned(decision))
+            break;
+        if (authorizeTransition(decision, state.authorizations).missing.length > 0)
+            break;
+        if (actionOf(decision) !== null)
+            break;
+        state = applyTransition(state, decision.id, effectsOf(decision));
+        applied.push(stepOf(decision));
+    }
+    return { state, applied };
+}
+/**
+ * The seal over the exact action emitted.
+ *
+ * Program, arguments, target, input and demanded evidence — change any of them and
+ * a result that quotes the old seal is answering about something else. Same reason
+ * `effectApprovalDigest` seals the classes being approved rather than the fact that
+ * an approval happened.
+ */
+export function actionDigest(action) {
+    return semanticDigest({
+        program: action.invocation.program,
+        args: [...action.invocation.args],
+        target: action.invocation.target,
+        input: action.invocation.input,
+        evidence: [...action.evidence],
+    });
+}
+/** The run's own coordinates, the only ones an invocation may reference. */
+function runBinding(state) {
+    return { session: state.session, code: sessionNumericCode(state.session) ?? state.session };
+}
+/**
+ * The action as this run would emit it: bound to its session, or refused.
+ *
+ * Every reader goes through here — the seal, the directive and the check `submit`
+ * runs against the result — so the invocation that gets sealed is the invocation
+ * that gets shown and the one the result is compared against. Binding in one of
+ * the three and not the others is how a run ends up rejecting its own action.
+ */
+function emittedAction(state, stopped) {
+    const declared = stopped === null ? null : actionOf(stopped);
+    if (declared === null)
+        return { action: null, unbound: null, outside: null };
+    const bound = bindAction(declared, runBinding(state));
+    if (!bound.ok)
+        return { action: null, unbound: bound.unbound, outside: null };
+    // Checked on the BOUND form: a placeholder could resolve into a path, so
+    // validating the template would be validating something nobody runs.
+    const outside = docsBoundaryBreach(bound.action, state.flow);
+    return outside === null
+        ? { action: bound.action, unbound: null, outside: null }
+        : { action: null, unbound: null, outside };
+}
+/**
+ * Why this boundary cannot be emitted at all — or `null` when it can.
+ *
+ * Four fail-closed causes, ordered by what the reader can do about them.
+ * Ownership answers first and is the one this tranche added: with the fallback
+ * retired there is no document to hand the step back to, so a transition the
+ * registry does not say the CLI owns stops the run naming itself instead of
+ * silently becoming prose somebody has to go read. An unbound placeholder and a
+ * `docs/` breach are defects OF THE REGISTRY too: the fix is a code change, and
+ * emitting either would print a command nobody can run or one that writes outside
+ * the lane its flow is allowed. Exhaustion is a defect of nothing — it is the run
+ * having asked the same thing as often as the chassis permits, and the answer is
+ * to take the gap somewhere a person can settle it rather than to ask a fourth
+ * time.
+ */
+function blockedCause(state, stopped, emitted) {
+    if (!owned(stopped)) {
+        return {
+            code: "FLOW_TRANSITION_UNOWNED",
+            message: `'${stopped.id}' no declara propiedad del CLI y ya no queda doctrina a la que devolverlo`,
+            action: "declarála en el registro de autoridad: desde el cierre de la migración toda transición de un recorrido público es 'cli-owned', y la ausencia es un error, no un fallback",
+        };
+    }
+    if (emitted.unbound !== null) {
+        return {
+            code: "FLOW_ACTION_UNBOUND",
+            message: `la acción de '${stopped.id}' referencia ${emitted.unbound} y esta corrida no puede resolverlo`,
+            action: "corregí la invocación del registro: una acción solo referencia las coordenadas de la corrida",
+        };
+    }
+    if (emitted.outside !== null) {
+        return {
+            code: "FLOW_DOCS_BOUNDARY_CROSSED",
+            message: `la acción de '${stopped.id}' escribe en ${emitted.outside} y el flow '${state.flow}' no tiene esa carpeta permitida`,
+            action: `este recorrido solo escribe ${describeAllowance(state.flow)}: promover algo a otra carpeta de docs es un paso 'export-*' aparte, nunca un efecto del loop`,
+        };
+    }
+    if (exhausted(state, stopped)) {
+        // Two different situations wear the same code, and saying which one this is
+        // matters: one continues on the next advance, the other cannot. Reporting the
+        // stricter message for both would tell somebody their run is stuck when it is
+        // about to move on.
+        const degradable = exhaustionSkip(state, stopped) !== null;
+        return {
+            code: "FLOW_BOUNDARY_EXHAUSTED",
+            message: `'${stopped.id}' agotó sus ${MAX_BOUNDARY_ATTEMPTS} intentos: contestarlo otra vez sería el bucle que la regla evita`,
+            action: degradable
+                ? `${DEGRADE_ACTION}; el próximo 'aw flow advance' lo pasa por alto dejando dicho por qué y sigue con el resto`
+                : `${DEGRADE_ACTION}, y resolvé este paso fuera de la corrida antes de seguir: saltearlo daría por aprobado un efecto que nadie aprobó, o por hecho algo que nada corrió`,
+        };
+    }
+    return null;
+}
+/** Where a gap goes when the loop stops re-firing it — the chassis' destination. */
+const DEGRADE_ACTION = "degradá el gap en vez de reintentarlo: llevalo a '## Open questions' del documento del flow —o al BACKLOG de la sesión si el flow no tiene documento— declarando que ya se intentó";
+/** Whether this run has already spent every attempt this boundary gets. */
+function exhausted(state, decision) {
+    return attemptsAt(state, decision.id) >= MAX_BOUNDARY_ATTEMPTS;
+}
+/**
+ * Whether the registry says this CLI owns the step.
+ *
+ * The vocabulary has one member, so every row shipped in {@link FLOW_DECISIONS}
+ * answers `true` and the compiler is what keeps it that way. The check survives
+ * for the journeys this engine does NOT build itself: a caller hands `advanceFlow`
+ * a list of decisions, and reading a field is cheaper than trusting that whoever
+ * assembled it kept the invariant. The three places that ask are the walk, the
+ * blocked cause and the skip — one predicate, so they cannot disagree.
+ */
+function owned(decision) {
+    return decision.ownership === "cli-owned";
+}
+/**
+ * Why an exhausted boundary is passed over — or `null` when it must not be.
+ *
+ * Degrading means what the chassis says it means: the gap stops being re-fired,
+ * it goes somewhere a person can settle it, and **the run goes on with the
+ * rest**. Blocking instead would be the dead end the rule exists to prevent — a
+ * boundary nobody can answer any more, on a run nobody can finish.
+ *
+ * Not every boundary may be passed over, and the exception is not a special
+ * case: a step that would EXERCISE something cannot be waved through. An
+ * authorization skipped is an effect nobody approved; a delegated step skipped
+ * is a search, a write or a check credited to nothing. Those stay blocked, and
+ * the block says so. What degrades is what only produces a verdict — a judgment
+ * or a preference — which is exactly the gap the doctrine degrades.
+ */
+function exhaustionSkip(state, decision) {
+    if (!exhausted(state, decision))
+        return null;
+    if (!owned(decision))
+        return null;
+    if (actionOf(decision) !== null)
+        return null;
+    if (authorizeTransition(decision, state.authorizations).missing.length > 0)
+        return null;
+    return `agotó sus ${MAX_BOUNDARY_ATTEMPTS} intentos: ${DEGRADE_ACTION}`;
+}
+/** The `docs/` folders a flow may write, said the way a person reads it. */
+function describeAllowance(flow) {
+    const allowed = DOCS_BOUNDARY[flow];
+    return allowed.length === 0 ? "ninguna carpeta de docs" : allowed.join(" y ");
+}
+export function resolveBoundary(state, journey) {
+    const stopped = journey[state.applied.length] ?? null;
+    const pending = journey.slice(state.applied.length).map((decision) => decision.id);
+    if (stopped === null) {
+        return {
+            stopped: null,
+            kind: "final",
+            authorization: null,
+            request: null,
+            action: null,
+            choices: [],
+            pending,
+            seal: boundarySeal(state, null),
+            error: null,
+        };
+    }
+    const emitted = emittedAction(state, stopped);
+    // Computed for `cli` rows only, which is where every row that really writes or
+    // runs lives today (13 of them, all `cli`). The day a row with authority `agent`
+    // or `human` declares a non-self-authorizable effect, this condition is the
+    // thing to revisit — and the ORDER is the open question there: approving a write
+    // before the agent has produced what gets written is not obviously right, so
+    // whichever phase introduces such a row decides it instead of inheriting it.
+    const authorization = stopped.authority === "cli" ? authorizeTransition(stopped, state.authorizations) : null;
+    // A cause that blocks outranks all of it: the boundary that says "nothing can
+    // continue and here is why" is never worth degrading into a question nobody can
+    // answer.
+    const blocked = blockedCause(state, stopped, emitted);
+    const kind = blocked === null ? boundaryKind(stopped, (authorization?.missing.length ?? 0) > 0) : "blocked";
+    return {
+        stopped,
+        kind,
+        authorization,
+        request: kind === "semantic" ? boundaryRequest(stopped, state) : null,
+        action: kind === "execution" ? emitted.action : null,
+        choices: choicesFor(kind, stopped, authorization),
+        pending,
+        seal: boundarySeal(state, stopped),
+        error: blocked,
+    };
+}
+/**
+ * Which boundary a stopped transition is, in the one order that holds.
+ *
+ * An effect nobody authorized outranks everything: approving an effect is not
+ * deciding a step, and letting any other axis answer first would hand a writing
+ * transition onwards with its effects unapproved — the authorization gate bypassed
+ * by a field that has nothing to do with it. Then the mode: what remains is a
+ * judgment, an invocation to run, or a preference.
+ *
+ * Ownership used to sit in the middle of that order, turning a step the CLI did
+ * not decide into its own kind of boundary. It no longer answers here at all —
+ * {@link blockedCause} refuses such a transition before this function runs, which
+ * is the difference between "read this document and come back" and "this cannot
+ * advance, and here is why".
+ */
+function boundaryKind(stopped, unauthorized) {
+    if (unauthorized)
+        return "authorization";
+    if (stopped.authority === "agent")
+        return "semantic";
+    return actionOf(stopped) === null ? "human" : "execution";
+}
+/**
+ * The seal of a boundary: the state it stands on, the transition it is about, and
+ * the action it names.
+ *
+ * Every boundary has one, not only the semantic ones — a human choice sent back
+ * against a state that moved is as stale as a semantic answer, and giving the two
+ * different staleness rules would leave the cheaper one unguarded. The semantic
+ * request's `input_digest` is computed over exactly this, so the two never differ.
+ *
+ * The action is inside the seal because a result is an assertion about a specific
+ * invocation: if the program, an argument, the target, the input or the demanded
+ * evidence changed, whatever came back answered a different question.
+ */
+export function boundarySeal(state, stopped) {
+    return semanticDigest(boundaryInputs(state, stopped));
+}
+/**
+ * What the seal is computed over — and what the semantic request declares as its
+ * own inputs, so the two digests are the same number by construction.
+ *
+ * Building them apart is how a system ends up with two staleness questions and a
+ * caller guessing which one it just answered.
+ */
+function boundaryInputs(state, stopped) {
+    const action = emittedAction(state, stopped).action;
+    return {
+        // The POSITION, not the whole file: a refused attempt is recorded in the
+        // state, and sealing it in would make the caller's own refusal come back as
+        // staleness on their next try. See `positionDigest`.
+        state: positionDigest(state),
+        transition: stopped?.id ?? null,
+        action: action === null ? null : actionDigest(action),
+    };
+}
+/** Build the directive for a resolved boundary. Shared by both verbs. */
+export function directiveFor(state, resolved, appliedNow, overrides = {}) {
+    const boundary = resolved.stopped === null
+        ? {
+            kind: "final",
+            transition: null,
+            authority: null,
+            ownership: null,
+            title: null,
+            document: null,
+        }
+        : {
+            kind: resolved.kind,
+            transition: resolved.stopped.id,
+            authority: resolved.stopped.authority,
+            ownership: resolved.stopped.ownership,
+            title: resolved.stopped.title,
+            document: resolved.stopped.document,
+        };
+    const planned = resolved.authorization?.planned ?? [];
+    const built = buildFlowDirective({
+        flow: state.flow,
+        session: state.session,
+        boundary,
+        outcome: overrides.outcome ?? (resolved.stopped === null ? "completed" : "needs_input"),
+        stateDigest: resolved.seal,
+        applied: appliedNow,
+        pending: resolved.pending,
+        request: resolved.request,
+        action: resolved.action,
+        choices: resolved.choices,
+        authorizations: state.authorizations,
+        // The cause of a block travels with the boundary that declares it: a
+        // `blocked` directive without its error is refused at construction.
+        error: resolved.error,
+        // The transition it stopped on is PLANNED even though nothing applied it: the
+        // person is being asked to approve those exact classes.
+        effects: {
+            planned: [...new Set([...state.effects.planned, ...planned])],
+            approved: state.effects.approved,
+            applied: state.effects.applied,
+        },
+        nextAction: overrides.nextAction ?? nextActionFor(boundary, resolved),
+    });
+    if (!built.ok)
+        return { ok: false, failure: built.failure };
+    return { ok: true, state, directive: built.directive };
+}
+/**
+ * The bounded request a semantic boundary carries.
+ *
+ * It reuses the existing `SemanticRequest` whole — contract, staleness seal,
+ * allowed destinations, limits and a visible `read_set` so the cost is auditable
+ * — instead of inventing a second envelope. A flow boundary asks for a judgment,
+ * not for files, which is why it declares no writable destination at all.
+ */
+export function boundaryRequest(decision, state) {
+    const vocabulary = decision.signals ?? [];
+    const taxonomy = vocabulary.length === 0
+        ? "Esta frontera no admite señales: contestá en 'decisions' lo que el contrato pide."
+        : `Declarás en 'signals' solo las que observás, de este vocabulario cerrado: ${vocabulary.join(", ")}. Una señal fuera de él no avanza el recorrido. El umbral sobre las señales lo aplica el CLI, no vos.`;
+    return buildSemanticRequest({
+        operation: `flow.${decision.id}`,
+        inputs: boundaryInputs(state, decision),
+        contract: `${decision.title}. Devolvé un único objeto JSON con el 'input_digest' de esta frontera. ${taxonomy} El CLI valida la respuesta antes de aplicar ninguna transición: una respuesta ausente, inválida, ambigua, fuera de alcance o vencida no cambia el estado ni produce efectos.`,
+        inventory: { flow: state.flow, applied: state.applied, signals: vocabulary },
+        allowedDestinations: [],
+        limits: { max_artifacts: 0, max_artifact_bytes: 0 },
+        readSet: [decision.document],
+        readSetBytes: 0,
+    });
+}
+/**
+ * The flow control, appended to every boundary that offers alternatives.
+ *
+ * BOTH halves, and the second one is what this phase added: the chassis' control
+ * is `Compactar | Cerrar`, and the engine only ever emitted `Cerrar` — so half
+ * the doctrine's own rule had no realization. Pausing under context pressure and
+ * stopping for good are different acts with different consequences, and a run
+ * that can only stop forces whoever is in it to choose between losing the thread
+ * and losing the work.
+ *
+ * Appended HERE and never by a row: a tranche must not be able to write a
+ * boundary nobody can walk away from or pause. Neither is recommended — the
+ * recommendation belongs to the content of the question, and nudging someone
+ * toward stopping or compacting would be the engine having an opinion about
+ * whether to keep going.
+ */
+export function flowControlChoices(stopping) {
+    return [
+        {
+            label: PAUSE_LABEL,
+            consequence: "se persiste el CHECKPOINT y la corrida retoma en esta misma frontera después de compactar el contexto",
+            recommended: false,
+        },
+        {
+            label: STOP_LABEL,
+            consequence: stopping ?? "el recorrido queda detenido acá, con su estado y su frontera persistidos",
+            recommended: false,
+        },
+    ];
+}
+/**
+ * A human boundary: the alternatives the row declares, or the generic pair.
+ *
+ * A migrated tranche names its own options — the ones its doctrine used to
+ * enumerate — and the engine emits them verbatim, which is what makes the
+ * directed journey equivalent to the one it replaces instead of merely similar.
+ * Whatever the row says, the flow control is appended.
+ */
+function humanChoices(decision) {
+    const own = alternativesOf(decision);
+    const resolve = own === null
+        ? [
+            {
+                label: "Resolver la frontera",
+                consequence: `decidís '${decision.title}' y el recorrido sigue desde ahí`,
+                recommended: true,
+            },
+        ]
+        : own.map((choice) => ({ ...choice }));
+    return [...resolve, ...flowControlChoices()];
+}
+/**
+ * An authorization boundary names the effect and what approving it costs.
+ *
+ * The recommendation is NOT "approve": nobody may be nudged into widening an
+ * authorization, so the alternatives state both consequences and let the person
+ * decide.
+ */
+function authorizationChoices(decision, authorization) {
+    const missing = authorization.missing.join(", ");
+    return [
+        {
+            label: "Autorizar el efecto",
+            consequence: `'${decision.title}' ejerce ${missing} y el recorrido sigue; la autorización queda registrada en la corrida`,
+            recommended: true,
+        },
+        ...flowControlChoices(`no se ejerce ${missing} y el recorrido queda detenido acá, sin nada aplicado`),
+    ];
+}
+function choicesFor(kind, stopped, unauthorized) {
+    if (kind === "authorization" && unauthorized !== null) {
+        return authorizationChoices(stopped, unauthorized);
+    }
+    return kind === "human" ? humanChoices(stopped) : [];
+}
+function nextActionFor(boundary, resolved) {
+    const stopped = resolved.stopped;
+    if (stopped === null)
+        return "no queda trabajo pendiente en este recorrido";
+    const submit = "respondé con 'aw flow submit' sobre la frontera vigente";
+    switch (boundary.kind) {
+        case "semantic":
+            return `${submit}: ${stopped.title}`;
+        case "human":
+            return `${submit}: elegí una de las alternativas emitidas para '${stopped.title}'`;
+        case "authorization": {
+            // The digest travels in the action so nobody has to derive it: the approval
+            // seals the exact classes this boundary named, and naming them here is what
+            // makes the next step discoverable without a field parallel to the receipt.
+            const digest = effectApprovalDigest(stopped.id, resolved.authorization?.planned ?? []);
+            const missing = resolved.authorization?.missing.join(", ") ?? "el efecto";
+            return `${submit} con --approval ${digest}, autorizando ${missing} para '${stopped.title}'`;
+        }
+        case "execution": {
+            // The exact invocation, projected — not a description of it. Whoever
+            // executes should never have to reconstruct the command from prose, and the
+            // evidence is named in the same breath so "it ran" and "here is the output"
+            // arrive together or not at all.
+            const action = resolved.action;
+            const call = action === null
+                ? stopped.id
+                : [action.invocation.program, ...action.invocation.args].join(" ");
+            const evidence = action?.evidence.join(", ") ?? "la evidencia exigida";
+            return `ejecutá '${call}' en ${action?.invocation.target ?? "el target declarado"} y ${submit} con su resultado real: outcome, la invocación que corriste y las validaciones ${evidence}. Una confirmación sin salida no aplica la transición`;
+        }
+        default:
+            return `resolvé el bloqueo de '${stopped.title}' y volvé a correr 'aw flow advance'`;
+    }
+}
+//# sourceMappingURL=advance.js.map

package/dist/application/flow/advance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance.js","sourceRoot":"","sources":["../../../src/application/flow/advance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,EACL,aAAa,EAGb,QAAQ,EACR,cAAc,EACd,SAAS,GACV,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAEL,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAKL,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,MAAM,GACP,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxF,OAAO,EAEL,qBAAqB,EACrB,eAAe,EACf,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,YAAY,EACZ,iBAAiB,GAClB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAEL,oBAAoB,EACpB,cAAc,GACf,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAoB5D,MAAM,UAAU,cAAc,CAAC,KAAmB;IAChD,MAAM,UAAU,GAAG,mBAAmB,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACnE,IAAI,UAAU,KAAK,IAAI;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAEnE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAChD,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IACzB,MAAM,UAAU,GAAe,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAE7E,iFAAiF;IACjF,iFAAiF;IACjF,iFAAiF;IACjF,+EAA+E;IAC/E,+BAA+B;IAC/B,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IAC5D,KAAK,GAAG,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,IAAI,IAAI,CAAC,CAAC;IACjD,+EAA+E;IAC/E,4EAA4E;IAC5E,4EAA4E;IAC5E,8EAA8E;IAC9E,+CAA+C;IAC/C,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;IAC7D,KAAK,GAAG,iBAAiB,CACvB,KAAK,EACL,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI;QAClC,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,CAC9D,CAAC;IACF,OAAO,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAS,IAAI,CACX,IAAkB,EAClB,OAAgC;IAEhC,IAAI,KAAK,GAAG,IAAI,CAAC;IACjB,MAAM,OAAO,GAAe,EAAE,CAAC;IAC/B,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAC1E,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,QAAQ,KAAK,SAAS;YAAE,MAAM;QAClC,6EAA6E;QAC7E,4EAA4E;QAC5E,0DAA0D;QAC1D,MAAM,OAAO,GACX,UAAU,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,YAAY,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACvF,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,KAAK,GAAG,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;YAC3C,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;YAC/C,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,SAAS,KAAK,KAAK;YAAE,MAAM;QACxC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;YAAE,MAAM;QAC5B,IAAI,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM;QAClF,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,IAAI;YAAE,MAAM;QACvC,KAAK,GAAG,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;QACjE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,MAAuB;IAClD,OAAO,cAAc,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO;QAClC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC;QACjC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,MAAM;QAChC,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC,KAAK;QAC9B,QAAQ,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC;KAC/B,CAAC,CAAC;AACL,CAAC;AAiCD,4EAA4E;AAC5E,SAAS,UAAU,CAAC,KAAmB;IACrC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;AAC9F,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,aAAa,CACpB,KAAmB,EACnB,OAA4B;IAE5B,MAAM,QAAQ,GAAG,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7D,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC7E,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IACtD,IAAI,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC9E,yEAAyE;IACzE,qEAAqE;IACrE,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IAC7D,OAAO,OAAO,KAAK,IAAI;QACrB,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;QACxD,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,YAAY,CACnB,KAAmB,EACnB,OAAqB,EACrB,OAA2D;IAE3D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,OAAO;YACL,IAAI,EAAE,yBAAyB;YAC/B,OAAO,EAAE,IAAI,OAAO,CAAC,EAAE,2EAA2E;YAClG,MAAM,EACJ,0KAA0K;SAC7K,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,qBAAqB;YAC3B,OAAO,EAAE,iBAAiB,OAAO,CAAC,EAAE,gBAAgB,OAAO,CAAC,OAAO,qCAAqC;YACxG,MAAM,EACJ,8FAA8F;SACjG,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QAC7B,OAAO;YACL,IAAI,EAAE,4BAA4B;YAClC,OAAO,EAAE,iBAAiB,OAAO,CAAC,EAAE,gBAAgB,OAAO,CAAC,OAAO,eAAe,KAAK,CAAC,IAAI,kCAAkC;YAC9H,MAAM,EAAE,+BAA+B,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,+FAA+F;SACpK,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC;QAC9B,4EAA4E;QAC5E,8EAA8E;QAC9E,8EAA8E;QAC9E,oBAAoB;QACpB,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;QAC3D,OAAO;YACL,IAAI,EAAE,yBAAyB;YAC/B,OAAO,EAAE,IAAI,OAAO,CAAC,EAAE,eAAe,qBAAqB,mEAAmE;YAC9H,MAAM,EAAE,UAAU;gBAChB,CAAC,CAAC,GAAG,cAAc,4FAA4F;gBAC/G,CAAC,CAAC,GAAG,cAAc,sJAAsJ;SAC5K,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,oFAAoF;AACpF,MAAM,cAAc,GAClB,oLAAoL,CAAC;AAEvL,2EAA2E;AAC3E,SAAS,SAAS,CAAC,KAAmB,EAAE,QAAsB;IAC5D,OAAO,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,qBAAqB,CAAC;AACjE,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,KAAK,CAAC,QAAsB;IACnC,OAAO,QAAQ,CAAC,SAAS,KAAK,WAAW,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,cAAc,CAAC,KAAmB,EAAE,QAAsB;IACjE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAClC,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACxF,OAAO,aAAa,qBAAqB,cAAc,cAAc,EAAE,CAAC;AAC1E,CAAC;AAED,4EAA4E;AAC5E,SAAS,iBAAiB,CAAC,IAA0B;IACnD,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IACpC,OAAO,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAChF,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,KAAmB,EACnB,OAAgC;IAEhC,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IACtD,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACnF,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,OAAO;YACL,OAAO,EAAE,IAAI;YACb,IAAI,EAAE,OAAO;YACb,aAAa,EAAE,IAAI;YACnB,OAAO,EAAE,IAAI;YACb,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE,EAAE;YACX,OAAO;YACP,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC;YAC/B,KAAK,EAAE,IAAI;SACZ,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9C,+EAA+E;IAC/E,iFAAiF;IACjF,4EAA4E;IAC5E,iFAAiF;IACjF,6EAA6E;IAC7E,6EAA6E;IAC7E,MAAM,aAAa,GACjB,OAAO,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1F,8EAA8E;IAC9E,gFAAgF;IAChF,UAAU;IACV,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACtD,MAAM,IAAI,GACR,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACjG,OAAO;QACL,OAAO;QACP,IAAI;QACJ,aAAa;QACb,OAAO,EAAE,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;QACrE,MAAM,EAAE,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;QACpD,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,aAAa,CAAC;QACjD,OAAO;QACP,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC;QAClC,KAAK,EAAE,OAAO;KACf,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,YAAY,CAAC,OAAqB,EAAE,YAAqB;IAChE,IAAI,YAAY;QAAE,OAAO,eAAe,CAAC;IACzC,IAAI,OAAO,CAAC,SAAS,KAAK,OAAO;QAAE,OAAO,UAAU,CAAC;IACrD,OAAO,QAAQ,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,YAAY,CAAC,KAAmB,EAAE,OAA4B;IAC5E,OAAO,cAAc,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CACrB,KAAmB,EACnB,OAA4B;IAE5B,MAAM,MAAM,GAAG,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC;IACpD,OAAO;QACL,yEAAyE;QACzE,4EAA4E;QAC5E,qDAAqD;QACrD,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC;QAC5B,UAAU,EAAE,OAAO,EAAE,EAAE,IAAI,IAAI;QAC/B,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC;KACtD,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,YAAY,CAC1B,KAAmB,EACnB,QAA0B,EAC1B,UAA+B,EAC/B,YAAkE,EAAE;IAEpE,MAAM,QAAQ,GACZ,QAAQ,CAAC,OAAO,KAAK,IAAI;QACvB,CAAC,CAAC;YACE,IAAI,EAAE,OAAO;YACb,UAAU,EAAE,IAAI;YAChB,SAAS,EAAE,IAAI;YACf,SAAS,EAAE,IAAI;YACf,KAAK,EAAE,IAAI;YACX,QAAQ,EAAE,IAAI;SACf;QACH,CAAC,CAAC;YACE,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE;YAC/B,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,SAAS;YACrC,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,SAAS;YACrC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,KAAK;YAC7B,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,QAAQ;SACpC,CAAC;IACR,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,EAAE,OAAO,IAAI,EAAE,CAAC;IACtD,MAAM,KAAK,GAAG,kBAAkB,CAAC;QAC/B,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,QAAQ;QACR,OAAO,EAAE,SAAS,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,aAAa,CAAC;QACvF,WAAW,EAAE,QAAQ,CAAC,IAAI;QAC1B,OAAO,EAAE,UAAU;QACnB,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,qEAAqE;QACrE,oEAAoE;QACpE,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,8EAA8E;QAC9E,wDAAwD;QACxD,OAAO,EAAE;YACP,OAAO,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;YAC7D,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ;YAChC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO;SAC/B;QACD,UAAU,EAAE,SAAS,CAAC,UAAU,IAAI,aAAa,CAAC,QAAQ,EAAE,QAAQ,CAAC;KACtE,CAAC,CAAC;IACH,IAAI,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAC5D,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;AACzD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,QAAsB,EAAE,KAAmB;IACzE,MAAM,UAAU,GAAG,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC;IAC1C,MAAM,QAAQ,GACZ,UAAU,CAAC,MAAM,KAAK,CAAC;QACrB,CAAC,CAAC,mFAAmF;QACrF,CAAC,CAAC,6EAA6E,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,uGAAuG,CAAC;IAChN,OAAO,oBAAoB,CAAC;QAC1B,SAAS,EAAE,QAAQ,QAAQ,CAAC,EAAE,EAAE;QAChC,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC;QACvC,QAAQ,EAAE,GAAG,QAAQ,CAAC,KAAK,0EAA0E,QAAQ,+KAA+K;QAC5R,SAAS,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE;QAC5E,mBAAmB,EAAE,EAAE;QACvB,MAAM,EAAE,EAAE,aAAa,EAAE,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE;QACnD,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC5B,YAAY,EAAE,CAAC;KAChB,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,kBAAkB,CAAC,QAAiB;IAClD,OAAO;QACL;YACE,KAAK,EAAE,WAAW;YAClB,WAAW,EACT,uGAAuG;YACzG,WAAW,EAAE,KAAK;SACnB;QACD;YACE,KAAK,EAAE,UAAU;YACjB,WAAW,EACT,QAAQ,IAAI,0EAA0E;YACxF,WAAW,EAAE,KAAK;SACnB;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,YAAY,CAAC,QAAsB;IAC1C,MAAM,GAAG,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IACrC,MAAM,OAAO,GACX,GAAG,KAAK,IAAI;QACV,CAAC,CAAC;YACE;gBACE,KAAK,EAAE,sBAAsB;gBAC7B,WAAW,EAAE,YAAY,QAAQ,CAAC,KAAK,kCAAkC;gBACzE,WAAW,EAAE,IAAI;aAClB;SACF;QACH,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;IAC3C,OAAO,CAAC,GAAG,OAAO,EAAE,GAAG,kBAAkB,EAAE,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;GAMG;AACH,SAAS,oBAAoB,CAC3B,QAAsB,EACtB,aAAsC;IAEtC,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjD,OAAO;QACL;YACE,KAAK,EAAE,qBAAqB;YAC5B,WAAW,EAAE,IAAI,QAAQ,CAAC,KAAK,YAAY,OAAO,uEAAuE;YACzH,WAAW,EAAE,IAAI;SAClB;QACD,GAAG,kBAAkB,CACnB,gBAAgB,OAAO,uDAAuD,CAC/E;KACF,CAAC;AACJ,CAAC;AAED,SAAS,UAAU,CACjB,IAAsB,EACtB,OAAqB,EACrB,YAA4C;IAE5C,IAAI,IAAI,KAAK,eAAe,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO,oBAAoB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACvD,CAAC;AAED,SAAS,aAAa,CAAC,QAAsB,EAAE,QAA0B;IACvE,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IACjC,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,8CAA8C,CAAC;IAC5E,MAAM,MAAM,GAAG,yDAAyD,CAAC;IACzE,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,GAAG,MAAM,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC;QACvC,KAAK,OAAO;YACV,OAAO,GAAG,MAAM,kDAAkD,OAAO,CAAC,KAAK,GAAG,CAAC;QACrF,KAAK,eAAe,CAAC,CAAC,CAAC;YACrB,4EAA4E;YAC5E,4EAA4E;YAC5E,4EAA4E;YAC5E,MAAM,MAAM,GAAG,oBAAoB,CAAC,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,aAAa,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;YACvF,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC;YAC1E,OAAO,GAAG,MAAM,mBAAmB,MAAM,iBAAiB,OAAO,UAAU,OAAO,CAAC,KAAK,GAAG,CAAC;QAC9F,CAAC;QACD,KAAK,WAAW,CAAC,CAAC,CAAC;YACjB,qEAAqE;YACrE,4EAA4E;YAC5E,4EAA4E;YAC5E,iCAAiC;YACjC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC/B,MAAM,IAAI,GACR,MAAM,KAAK,IAAI;gBACb,CAAC,CAAC,OAAO,CAAC,EAAE;gBACZ,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACvE,MAAM,QAAQ,GAAG,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,sBAAsB,CAAC;YACvE,OAAO,YAAY,IAAI,QAAQ,MAAM,EAAE,UAAU,CAAC,MAAM,IAAI,qBAAqB,MAAM,MAAM,kFAAkF,QAAQ,uDAAuD,CAAC;QACjP,CAAC;QACD;YACE,OAAO,0BAA0B,OAAO,CAAC,KAAK,sCAAsC,CAAC;IACzF,CAAC;AACH,CAAC"}

package/dist/application/flow/flow-service.js

@@ -0,0 +1,65 @@
+/**
+ * The command's half: find the session, take the run's lock, advance, persist.
+ *
+ * Everything decision-shaped lives in the engine and the registry; what is here
+ * is the plumbing that makes the advance atomic and addressable — which session,
+ * which state, one write.
+ */
+import { journeyOfFlow } from "../../domain/flow/authority.js";
+import { newRunState } from "../../domain/flow/run-state.js";
+import { WORKLINE_FLOWS } from "../capability/compose.js";
+import { resolveSessionTarget } from "../session-resolver.js";
+import { advanceFlowRun } from "./advance.js";
+import { applyUnderLock, locateRun } from "./run-state-service.js";
+export async function advanceFlow(fs, paths, input) {
+    // A write path: a closed line is never advanced by accident, and nothing is
+    // chosen by recency — several active sessions with no association is ambiguous.
+    const resolution = await resolveSessionTarget(fs, paths, {
+        ...(input.code !== undefined ? { code: input.code } : {}),
+        ...(input.contextId !== undefined ? { contextId: input.contextId } : {}),
+        allowClosed: false,
+        bind: true,
+    });
+    if (resolution.outcome !== "resolved")
+        return { ok: false, session: resolution };
+    const session = resolution.session.folder;
+    const location = locateRun(paths, session);
+    const applied = await applyUnderLock(fs, location, (current) => {
+        const seeded = current ?? seed(input, session);
+        if ("failure" in seeded)
+            return { ok: false, failure: seeded.failure };
+        const advance = advanceFlowRun({
+            state: seeded,
+            journey: journeyOfFlow(seeded.flow),
+        });
+        if (!advance.ok)
+            return { ok: false, failure: advance.failure };
+        return { ok: true, state: advance.state, value: advance.directive };
+    }, { allowAbsent: input.adopt });
+    if (!applied.ok)
+        return { ok: false, failure: applied.failure };
+    return { ok: true, directive: applied.value };
+}
+/**
+ * The state a legacy session gets when it is adopted.
+ *
+ * Adoption needs the flow named explicitly: guessing it from the folder suffix
+ * would make the CLI infer the one thing the whole run hangs off, and a wrong
+ * guess would walk the wrong journey.
+ */
+function seed(input, session) {
+    const flow = input.flow;
+    if (flow === undefined || !WORKLINE_FLOWS.includes(flow)) {
+        return {
+            failure: {
+                code: "FLOW_ADOPTION_FLOW_MISSING",
+                message: flow === undefined
+                    ? "adoptar una sesión legacy exige nombrar su flow"
+                    : `'${flow}' no es un flow de Workline`,
+                action: `pasá --flow con uno de: ${WORKLINE_FLOWS.join(", ")}`,
+            },
+        };
+    }
+    return newRunState(flow, session);
+}
+//# sourceMappingURL=flow-service.js.map

package/dist/application/flow/flow-service.js.map

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