@genesislcap/ai-assistant 15.23.3 → 15.24.0

package/dist/dts/main/context-gate-controller.d.ts

@@ -0,0 +1,197 @@
+import type { ChatConfig, ChatMessage } from '@genesislcap/foundation-ai';
+import type { ContextReserveResolution } from '../components/ai-driver/ai-driver';
+import type { ContextGuardPolicy } from '../components/chat-driver/chat-driver';
+import type { CompactionProjection } from '../utils/context-tokens';
+import type { CompactionPlanOptions } from '../utils/history-transform';
+import { type ResolvedContextBudget } from '../utils/resolve-context-budget';
+/** What the controller needs from its host, as callbacks so it holds no element reference. */
+export interface ContextGateDeps {
+    chatConfig: () => ChatConfig;
+    /**
+     * The Redux mirror, not the driver's history. Safe rather than sloppy: the two
+     * lists only ever drift at the tail, and nothing here inspects the tail.
+     */
+    messages: () => readonly ChatMessage[];
+    /** The live gauge figure — what the context indicator shows. */
+    contextTokens: () => number | undefined;
+    /**
+     * The figure the GATE is judged against: `contextTokens` as of the last moment
+     * no turn was running (GENC-1582). Distinct from the live gauge on purpose — see
+     * the element's `_gateContextTokens`. Falls back to the live figure when unset.
+     */
+    gateContextTokens: () => number | undefined;
+    contextLimit: () => number | undefined;
+    /**
+     * Headroom the next turn needs and which agent set it, resolved by the driver
+     * against live routing state (GENC-1582). A callback because reaching it means
+     * going through the driver, which the element owns — this controller never
+     * touches a driver (§11.2 constraint 2).
+     */
+    contextReserve: () => ContextReserveResolution | undefined;
+    /**
+     * The preamble the driver actually measured on the last request, when it builds
+     * requests at all. Replaces the estimate this controller used to compute (and
+     * memoize) from the transcript: a measurement beats a walk, and it is why the
+     * `systemOverhead` input to `resolveContextBudget` is gone.
+     */
+    preambleTokens: () => number | undefined;
+    /** The driver's plan for the exact history `compact()` acts on. */
+    compactionPlanFor: (options: CompactionPlanOptions) => CompactionProjection | null;
+    /** A budget wall outranks the gate, so the notice getters have to see it. */
+    bannerVisible: () => boolean;
+    effectiveBlockedReason: () => string;
+    /** Non-null while a guided flow owns the turn — a flow is warned, never blocked. */
+    flowOwnerAgentName: () => string | null;
+}
+/**
+ * The context gate: how close the conversation is to the model's window, what
+ * compacting would reclaim, and the copy that states both (GENC-1567).
+ *
+ * Owns **no state at all** — every member derives from the callbacks above. That
+ * is what makes it the safest of these extractions: there is no field to forget
+ * to mark `@observable`, so the observability trap in `docs/code-health.md` §11.4
+ * cannot bite here.
+ *
+ * @internal
+ */
+export declare class ContextGateController {
+    private readonly deps;
+    constructor(deps: ContextGateDeps);
+    /** Window, warn/block thresholds and compaction sizing for the active model. */
+    get budget(): ResolvedContextBudget;
+    /**
+     * What compacting right now would reclaim, or `null` when it would not be worth
+     * it. Sized against {@link ContextGateController.budget}, so the plan aims at
+     * this model's window rather than a fixed default.
+     *
+     * Reads `messages` to stay reactive as the conversation grows: the driver's
+     * history is not a tracked observable, so every consumer keys its re-evaluation
+     * off the Redux mirror.
+     *
+     * Deliberately NOT memoized on `messages` identity: it runs against the driver's
+     * history, which can move without the mirror moving (a mid-turn `condenseWhen`
+     * rewrite), so an identity key would risk serving a plan for a transcript the
+     * driver no longer has.
+     */
+    get plan(): CompactionProjection | null;
+    /**
+     * Guard policy pushed to the driver, or `undefined` when the host has switched
+     * the gate off — so `enabled: false` really does mean no local blocking of any
+     * kind, UI or mid-loop.
+     *
+     * A MARGIN, not a threshold: the driver resolves the window of the provider each
+     * call actually goes to. The fallback window rides along because the driver
+     * cannot learn it any other way — without it, a host that knows its window while
+     * its provider does not report one had `fallbackContextLimit` protecting the
+     * composer and nothing else.
+     */
+    get guardPolicy(): ContextGuardPolicy | undefined;
+    /**
+     * How close this conversation is to the model's context window.
+     *
+     * **Derived, never latched** — the opposite of the budget wall. A wall stays set
+     * because nothing the user does fixes it; this clears itself the moment the
+     * conversation shrinks, which is precisely what the user is being asked to do.
+     *
+     * **A flow in progress is never blocked, only warned.** Machine state lives
+     * outside the transcript, so a stateful flow is not desynced by compaction — but
+     * the summary can still drop detail the flow's own prompt leans on, and blocking
+     * mid-journey would strand the user between a flow they cannot finish and a
+     * compaction that is a poor idea right there.
+     */
+    get gate(): 'ok' | 'warn' | 'blocked';
+    /**
+     * WHY the composer is blocked, when it is (GENC-1582). `undefined` unless
+     * {@link ContextGateController.gate} is `'blocked'`.
+     *
+     * - `'transcript'` — the conversation has grown into the reserve.
+     * - `'model'` — the reserve meets or exceeds the whole window, so `blockAt` is 0
+     *   and EVERY message is refused, including the first of an empty chat.
+     *
+     * Keyed off `blockAt === 0`, deliberately NOT off whether a compaction plan
+     * exists. A null plan has two unrelated causes — nothing left worth summarizing,
+     * versus a window that cannot host the agent at all — and only the second is a
+     * statement about the configuration rather than the transcript.
+     *
+     * **This drives behaviour, not copy.** It reads as though it should also pick the
+     * wording, and GENC-1582 had it do so: the `'model'` branch told the user to
+     * switch to a model with a larger context window, or pick a different agent.
+     * Removed, because the assistant offers no way to do either — the model follows
+     * from the host's provider registry and each agent's `provider` field, and the
+     * only user-facing lever is the agent picker, which is triple-gated
+     * (`agentPicker` enabled, two or more agents, at least one with
+     * `manualSelection.enabled`) and commonly absent. Copy that names a control the
+     * user does not have is worse than copy that names a remedy which merely turns
+     * out to be insufficient, and `contextGateReason` is not host-overridable, so
+     * nobody downstream could correct it either. Both causes now read the GENC-1567
+     * sentence.
+     *
+     * What it still decides is `sessionMenuForcedByContext`: the transcript cause
+     * forces the session menu open so a user told to compact can reach Compact, and
+     * the model cause deliberately does not, because there Compact and Clear are
+     * both futile and a menu of dead actions helps nobody.
+     *
+     * The block itself is correct in both cases and must stay: an agent that
+     * measurably cannot complete a turn in this window would otherwise start one and
+     * die mid-loop on a provider context error, with partial writes and no clean
+     * exit. Refusing up front is the better failure.
+     */
+    get blockCause(): 'transcript' | 'model' | undefined;
+    /**
+     * What the composer notice says about the gate.
+     *
+     * The copy is a function of whether compaction can actually clear it, which is
+     * why it reads {@link ContextGateController.plan} rather than assuming. Telling
+     * someone to compact when the projection says it would not free enough — a tail
+     * that is one indivisible tool result, say — sends them into a summarizer call
+     * that leaves them exactly where they were.
+     */
+    get gateReason(): string;
+    /**
+     * Short label the session-menu pill wears while the gate is active — the primary
+     * visible signal, in place of a banner.
+     *
+     * It states the CONDITION only; the remedy lives in the placeholder once the
+     * composer is actually blocked, which is the moment the user needs to be told
+     * what to do rather than merely warned.
+     */
+    get gateLabel(): string;
+    /** Tooltip and hint for the Compact row — why it is or is not available. */
+    get compactHint(): string;
+    /**
+     * Whether the menu's "Compact" action would do anything. Delegates to the
+     * driver's plan so the gate uses the exact same history `compact()` acts on,
+     * judged against the same budget — one source of truth for both whether a cut is
+     * legal and whether it reclaims enough.
+     */
+    get compactable(): boolean;
+    /**
+     * Whether the composer notice has anything to show — a budget wall or the gate.
+     * One region for both, so the live region stays single and registered.
+     */
+    get noticeVisible(): boolean;
+    /**
+     * Text for that region. A budget wall outranks the gate: it is the condition the
+     * user cannot clear, so it must not be hidden behind advice about compacting that
+     * would not restore sending anyway.
+     */
+    get noticeText(): string;
+    /**
+     * Whether the notice region should be announced but not drawn.
+     *
+     * The gate shows itself visually through the pill's label, the composer outline
+     * and the placeholder — a strip of prose on top would be a fourth statement of
+     * the same thing. But dropping the region outright would be an accessibility
+     * regression: a `role="status"` region announces MUTATIONS to a region already
+     * being observed, and it is the only announcement available here, because the
+     * composer flips to `disabled` at the same moment and a disabled control is out
+     * of the tab order — so neither the placeholder nor an `aria-label` on it is ever
+     * voiced.
+     *
+     * So the region stays mounted, keeps its text and keeps announcing; only the
+     * visual treatment is withheld. A budget wall still draws its banner, because
+     * that condition has no other visible expression.
+     */
+    get noticeSrOnly(): boolean;
+}
+//# sourceMappingURL=context-gate-controller.d.ts.map

package/dist/dts/main/context-gate-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-gate-controller.d.ts","sourceRoot":"","sources":["../../../src/main/context-gate-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AAEzC,8FAA8F;AAC9F,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,UAAU,CAAC;IAC7B;;;OAGG;IACH,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IACvC,gEAAgE;IAChE,aAAa,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACxC;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC5C,YAAY,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACvC;;;;;OAKG;IACH,cAAc,EAAE,MAAM,wBAAwB,GAAG,SAAS,CAAC;IAC3D;;;;;OAKG;IACH,cAAc,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACzC,mEAAmE;IACnE,iBAAiB,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,oBAAoB,GAAG,IAAI,CAAC;IACnF,6EAA6E;IAC7E,aAAa,EAAE,MAAM,OAAO,CAAC;IAC7B,sBAAsB,EAAE,MAAM,MAAM,CAAC;IACrC,oFAAoF;IACpF,kBAAkB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,eAAe;IAElD,gFAAgF;IAChF,IACI,MAAM,IAAI,qBAAqB,CAclC;IAED;;;;;;;;;;;;;OAaG;IACH,IACI,IAAI,IAAI,oBAAoB,GAAG,IAAI,CAQtC;IAED;;;;;;;;;;OAUG;IACH,IACI,WAAW,IAAI,kBAAkB,GAAG,SAAS,CAMhD;IAED;;;;;;;;;;;;OAYG;IACH,IACI,IAAI,IAAI,IAAI,GAAG,MAAM,GAAG,SAAS,CAWpC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,IACI,UAAU,IAAI,YAAY,GAAG,OAAO,GAAG,SAAS,CAGnD;IAED;;;;;;;;OAQG;IACH,IACI,UAAU,IAAI,MAAM,CAyBvB;IAED;;;;;;;OAOG;IACH,IACI,SAAS,IAAI,MAAM,CAStB;IAED,4EAA4E;IAC5E,IACI,WAAW,IAAI,MAAM,CAKxB;IAED;;;;;OAKG;IACH,IACI,WAAW,IAAI,OAAO,CAEzB;IAED;;;OAGG;IACH,IACI,aAAa,IAAI,OAAO,CAE3B;IAED;;;;OAIG;IACH,IACI,UAAU,IAAI,MAAM,CAGvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,IACI,YAAY,IAAI,OAAO,CAE1B;CACF"}

package/dist/dts/main/cost-ledger-controller.d.ts

@@ -0,0 +1,228 @@
+import type { AggregateUsage, AIProviderRegistryStatusEntry, ChatConfig, ChatMessage } from '@genesislcap/foundation-ai';
+import type { SessionPersistenceProvider } from '../state/persistence/session-persistence-provider';
+import { type CostSessionModelEntry, type CostSessionRecord } from '../utils/cost-session-history';
+import { type ResolvedCostHistoryConfig } from '../utils/resolve-cost-history-config';
+/** What the controller needs from its host, as callbacks so it holds no element reference. */
+export interface CostLedgerDeps {
+    chatConfig: () => ChatConfig;
+    /** The transcript, for title derivation and the per-row model list. */
+    messages: () => readonly ChatMessage[];
+    /** Live session usage — the figure every row is a projection of. */
+    sessionUsage: () => AggregateUsage;
+    providerStatuses: () => AIProviderRegistryStatusEntry[];
+    /**
+     * `persistence.enabled && persistence.provider` — whether the transcript on screen
+     * speaks for this project's history. The whole banking split turns on it; see
+     * {@link CostLedgerController.bankedUsageFor}.
+     */
+    persistenceActive: () => boolean;
+    /** The *wired* session key, which can lag the attributes during a deferred switch. */
+    stateKey: () => string | undefined;
+    headerTitle: () => string | undefined;
+    /** The host's persistence provider, whose cost-history methods are optional. */
+    provider: () => SessionPersistenceProvider | undefined;
+    /** The element `id`, the middle fallback for the history scope. */
+    elementId: () => string;
+}
+/**
+ * The cost ledger: this session's usage, the persisted per-project build history it
+ * upserts into, and the pre-transcript ("banked") spend that makes a row report a
+ * project's LIFETIME total rather than whatever is currently on screen (GENC-1475).
+ *
+ * The invariant the whole file protects: **a row moves forward, never backwards.**
+ * Every figure is derived from state rather than incremented, so the several element
+ * instances one session sees — layout re-renders, popout, docking — write the same
+ * row instead of each adding a contribution. `cost-session-banking.test.ts` pins the
+ * cases where earlier attempts got this wrong in both directions.
+ *
+ * @internal
+ */
+export declare class CostLedgerController {
+    private readonly deps;
+    /**
+     * Persisted rows, newest write wins. Observable because the Usage tab renders them
+     * (through the host's `costSessionHistory` and `sortedCostSessionHistory`), and
+     * because the derived lifetime totals below have to re-run when a row lands.
+     */
+    history: CostSessionRecord[];
+    /**
+     * Title tracked for the in-flight session, and the session key it accrued under so
+     * a title change can tell a rename (same key) from a project switch (key already
+     * flipped) — see {@link CostLedgerController.syncActiveTitle}.
+     *
+     * Not observable: read only by the title getter's own fallback chain, which already
+     * depends on `chatConfig` and `messages`, and written only from lifecycle hooks.
+     */
+    private activeTitle;
+    private activeKey?;
+    /**
+     * What the last read of the backing store told us, and the two gates every write
+     * consults. Neither is observable — nothing renders them.
+     *
+     * `loaded`: whether the row list reflects storage yet. Gates writes so a project's
+     * banked spend is never derived from a ledger that simply hasn't arrived.
+     *
+     * `unreadable`: set when a provider read failed, latching writes off for this
+     * page-load. `saveCostHistory` replaces the whole stored list, so writing anything
+     * derived from the empty list we fell back to would destroy rows we never read.
+     *
+     * Private, though `cost-session-banking.test.ts` drives both to model a provider
+     * read that is in flight or has failed. That works because the test reaches them
+     * through an `as unknown as { costLedger: … }` structural cast, which erases the
+     * class type — so exposing them bought nothing and only put a mutable latch on the
+     * surface of an `@internal` controller (PR #2503 review).
+     */
+    private loaded;
+    private unreadable;
+    /** Pending (adopted but unwritten) ledger changes — see {@link CostLedgerController.persist}. */
+    private dirty;
+    private flushTimer?;
+    constructor(deps: CostLedgerDeps);
+    /** Resolved cost tab and build-history settings from `chatConfig.costHistory`. */
+    get config(): ResolvedCostHistoryConfig;
+    /**
+     * Distinct models the registry currently resolves to — the live session's model chips.
+     *
+     * `providerStatuses` carries one entry per registry SLOT, so a vendor configured across several
+     * tiers that happen to resolve to the same model reports it once per tier, and the chips
+     * rendered it once per tier too. Which tier a model came from is not what these chips are for.
+     *
+     * Deduped on the label actually displayed, not on `status.model`: a slot whose provider reports
+     * no model falls back to the slot's own name, and those are distinct per slot, so keying on the
+     * label keeps them from collapsing into one another.
+     */
+    get uniqueProviderModels(): CostSessionModelEntry[];
+    /**
+     * Build history for display: most recently worked on first.
+     *
+     * The stored order is insertion order (see `upsertRecord`), which leaves a project returned to
+     * sitting wherever it was first seen — so ordering is applied here, on read, where it also
+     * covers rows a host provider supplied.
+     */
+    get sortedHistory(): CostSessionRecord[];
+    /**
+     * Lifetime usage across every project in the history scope — cost and all four token
+     * buckets. What the Usage tab's lifetime section renders.
+     *
+     * Rows ONLY — deliberately not rows + live session. Each row holds a project's lifetime
+     * usage and the active project's row is kept current on every transcript change, so
+     * adding the live total would count this project's spend twice. That double-count is what
+     * made the figure grow on every refresh: a page-hide banked a row while the restored
+     * session still carried the same spend.
+     */
+    get cumulativeUsage(): AggregateUsage;
+    /** Lifetime USD across every project in the history scope. */
+    get cumulativeCostUsd(): number;
+    /**
+     * Whether the live session figures amount to this project's whole history, which is true
+     * exactly when the transcript is restored on load. Drives the Usage tab's live labels
+     * ("Project cost" vs "Session cost") so they state the scope rather than imply one.
+     *
+     * Note this is NOT what makes the *rows* lifetime — those bank their pre-transcript spend
+     * (see `CostSessionRecord.banked`) and are lifetime either way.
+     */
+    get liveUsageIsProjectLifetime(): boolean;
+    /** Label shown on the Usage tab for the in-flight session (app title or first user phrase). */
+    get liveTitle(): string | undefined;
+    /**
+     * Write this session's usage into persisted build history as a single row keyed by the
+     * session key, replacing any existing row for that key.
+     *
+     * **Idempotent** — safe to call per turn, on tab close, and on a title change alike.
+     * The name is historical: it does NOT end the session or reset the running totals.
+     * Resetting them is what used to double-count spend, since the row was banked while the
+     * persisted transcript still carried the same usage, so a reload restored it and the
+     * Usage tab counted both.
+     *
+     * No-op unless `chatConfig.costHistory.enabled` is `true`, when the live session has no
+     * usage yet, or when the session has no key to upsert against. Gating on the *live*
+     * figures (not the banked total) means a reload that restores nothing rewrites nothing.
+     */
+    finalize(options?: {
+        title?: string;
+    }): void;
+    /**
+     * Spend for `projectKey` that predates the current transcript, resolved once per SESSION and
+     * shared by every element instance wired to it (see `banked-usage-baselines`), so it cannot
+     * drift as the row it came from is rewritten by our own upserts.
+     *
+     * The two cases turn on whether the transcript is authoritative for this project:
+     *
+     * - **Transcript restored** (`persistenceActive`): it already accounts for everything after
+     *   the previous row's own banked figure, so carry that figure forward unchanged. Re-banking
+     *   `usage` here would add the restored history to itself on every reload.
+     * - **Transcript starts empty**: nothing on screen accounts for the previous total, so the
+     *   whole of it becomes banked. Without this the next turn would rewrite the row downwards
+     *   to just that turn, losing the project's earlier spend.
+     *
+     * The baseline is deliberately NOT element or controller state. This element is remounted
+     * repeatedly inside a single session (the host re-rendering its layout, popping out, docking)
+     * and a fresh instance re-deriving would take the second branch against rows that already hold
+     * the live transcript — banking the session as its own baseline. Keying on the session instead
+     * means a remount inherits the baseline that transcript was paired with.
+     */
+    private bankedUsageFor;
+    /**
+     * Re-baseline this session against an emptied transcript: what came before, plus what the
+     * transcript being discarded proved. `discarded` must be read BEFORE the live figures are
+     * reset, since that is the only record of the latter.
+     *
+     * Not the same as dropping the baseline. Dropping it re-derives through `persistenceActive`,
+     * and with persistence ON that carries the row's *old* banked figure forward — discarding
+     * every turn between the last baseline and the clear. The transcript is gone either way, so
+     * the branch that reads it as authoritative no longer applies.
+     *
+     * Derived from the memoised baseline and the live figure rather than from the project's row,
+     * because a row is only as current as the last {@link CostLedgerController.finalize} — which
+     * skips its write while the ledger is unloaded, and while the session has no usage yet.
+     */
+    rebaselineOnClearedTranscript(key: string, discarded: AggregateUsage): void;
+    /** Remove one entry from persisted build history. */
+    remove(id: string): void;
+    /** Clear all persisted build history for this assistant scope. */
+    clear(): void;
+    private scope;
+    /** Re-read the ledger for the current scope. Runs on connect and on every `chatConfig` rebind. */
+    reload(): void;
+    /**
+     * The persistence provider, but only when it implements BOTH cost-history methods.
+     *
+     * Both or neither: a provider that can save but not load would silently accumulate a
+     * ledger nobody ever reads back, so a partial implementation is treated as absent and
+     * falls back to `localStorage`.
+     */
+    private costHistoryProvider;
+    /**
+     * Adopt `records` as the live list, and schedule a write to whichever backend owns cost
+     * history — the provider when the host implements it, else `localStorage`.
+     *
+     * The list is adopted synchronously because that is what the Usage tab renders; only the
+     * *write* is deferred. This runs on every usage change (about once per LLM call, plus once
+     * per sub-agent turn) and each write serialises the whole ledger, so coalescing cuts a
+     * per-turn `localStorage.setItem` or network round-trip down to one per quiet period. Safe
+     * because the write is a full replace of idempotent state: the newest call wins and no
+     * intermediate state is meaningful. Flushed on `pagehide` and disconnect so nothing is lost.
+     */
+    private persist;
+    /**
+     * Write the pending ledger now. Safe to call when nothing is pending.
+     *
+     * Provider writes are fire-and-forget and best-effort: the ledger is accounting, not
+     * conversation content, so a failed write is logged and never surfaced into the chat. On
+     * `pagehide` the `localStorage` path completes synchronously; a provider write is subject to
+     * the same unload race as every other network save the assistant makes.
+     */
+    flush(): void;
+    /**
+     * Finalize the previous session when the host-provided title changes — a rename should land on
+     * the row under its old name rather than silently relabelling accrued spend.
+     *
+     * Only when the session key still matches the one that title accrued under. Hosts change
+     * `costHistory.title` on project SWITCH too, and if the key has already flipped, this would
+     * upsert the outgoing project's live usage onto the incoming project's row as
+     * `banked + old live`, inflating it. Under the old append model a mis-keyed write left a stray
+     * row; with the upsert it overwrites a real one.
+     */
+    syncActiveTitle(): void;
+}
+//# sourceMappingURL=cost-ledger-controller.d.ts.map

package/dist/dts/main/cost-ledger-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost-ledger-controller.d.ts","sourceRoot":"","sources":["../../../src/main/cost-ledger-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,6BAA6B,EAC7B,UAAU,EACV,WAAW,EACZ,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mDAAmD,CAAC;AAOpG,OAAO,EAQL,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAMvC,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,sCAAsC,CAAC;AAW9C,8FAA8F;AAC9F,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,UAAU,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,SAAS,WAAW,EAAE,CAAC;IACvC,oEAAoE;IACpE,YAAY,EAAE,MAAM,cAAc,CAAC;IACnC,gBAAgB,EAAE,MAAM,6BAA6B,EAAE,CAAC;IACxD;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,OAAO,CAAC;IACjC,sFAAsF;IACtF,QAAQ,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACnC,WAAW,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACtC,gFAAgF;IAChF,QAAQ,EAAE,MAAM,0BAA0B,GAAG,SAAS,CAAC;IACvD,mEAAmE;IACnE,SAAS,EAAE,MAAM,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAoB;IA8CnB,OAAO,CAAC,QAAQ,CAAC,IAAI;IA7CjC;;;;OAIG;IACS,OAAO,EAAE,iBAAiB,EAAE,CAAM;IAE9C;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,SAAS,CAAC,CAAS;IAM3B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,iGAAiG;IACjG,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,CAAC,CAAgC;gBAEtB,IAAI,EAAE,cAAc;IAEjD,kFAAkF;IAClF,IACI,MAAM,IAAI,yBAAyB,CAEtC;IAED;;;;;;;;;;OAUG;IACH,IACI,oBAAoB,IAAI,qBAAqB,EAAE,CAiBlD;IAED;;;;;;OAMG;IACH,IACI,aAAa,IAAI,iBAAiB,EAAE,CAEvC;IAED;;;;;;;;;OASG;IACH,IACI,eAAe,IAAI,cAAc,CAKpC;IAED,8DAA8D;IAC9D,IACI,iBAAiB,IAAI,MAAM,CAE9B;IAED;;;;;;;OAOG;IACH,IACI,0BAA0B,IAAI,OAAO,CAExC;IAED,+FAA+F;IAC/F,IACI,SAAS,IAAI,MAAM,GAAG,SAAS,CAKlC;IAED;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IA6C5C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,cAAc;IAWtB;;;;;;;;;;;;;OAaG;IACH,6BAA6B,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,GAAG,IAAI;IAyC3E,qDAAqD;IACrD,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAcxB,kEAAkE;IAClE,KAAK,IAAI,IAAI;IAgBb,OAAO,CAAC,KAAK;IAMb,kGAAkG;IAClG,MAAM,IAAI,IAAI;IAgDd;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAAO;IAWf;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI;IAmBb;;;;;;;;;OASG;IACH,eAAe,IAAI,IAAI;CAYxB"}