@corensystem/coren-ui 1.0.0-next.20260924.75108.887a9c2

package/dist/pages/wc3-analysis-shared.d.mts

@@ -0,0 +1,346 @@
+import { Mono, Pane, TypeGlyphLabel, Wc3LineageNavTarget, lineageNav } from "./wc3-lineage-shared.mjs";
+import { WC3_ANALYSIS_GROUP_BYS, WC3_ANALYSIS_METRICS, WC3_ANALYSIS_SEVERITIES, WC3_ANALYSIS_SOURCE_DATASET_IDS, WC3_ANALYSIS_STAGES, WC3_ANALYSIS_WINDOWS, WC3_OBSERVATION_ROWS, WC3_WORKER_ROWS, Wc3AnalysisFilter, Wc3AnalysisGrain, Wc3AnalysisGroupBy, Wc3AnalysisJoinedRow, Wc3AnalysisMetric, Wc3AnalysisMode, Wc3AnalysisRouteId, Wc3AnalysisSpec, Wc3AnalysisStageId, Wc3AnalysisViz, Wc3Materialisation, Wc3SavedAnalysis, Wc3WorkerRow, analysisDataset, analysisDatasetMaterialised, analysisDatasetName, analysisDatasetRows, analysisMetric, analysisMetricMissingInput, analysisWorker, wc3AnalysisDefaultSpec } from "./wc3-analysis-data.mjs";
+import { ReactElement, ReactNode } from "react";
+//#region src/pages/wc3-analysis-shared.d.ts
+/** The engine a spec routes to, plus the verbatim justification the prototype gives. */
+export type Wc3AnalysisRoute = {
+  id: Wc3AnalysisRouteId;
+  label: string;
+  why: string;
+};
+/** One grouped aggregate row. `vals` is keyed by metric id; a metric that returns null shows "—". */
+export type Wc3AnalysisGroup = {
+  key: string;
+  n: number;
+  vals: Record<string, number | null>;
+};
+/** The result of ONE execution of ONE spec. Aggregates only — the full row set is never held. */
+export type Wc3AnalysisResult = {
+  groups: Wc3AnalysisGroup[];
+  /** Metrics with a compute fn. */
+  supported: Wc3AnalysisMetric[];
+  /** Metrics whose `needs` dataset has no materialised rows. */
+  blocked: Wc3AnalysisMetric[];
+  /** The source dataset itself returned 0 rows. */
+  sourceEmpty: boolean;
+  /** Any source row carries `observed_at`. */
+  sourceHasTimeColumn: boolean;
+  /** Source rows + worker rows when a traversal/join runs. */
+  rowsScanned: number;
+  /** After window + filters. */
+  rowsMatched: number;
+  /** === groups.length */
+  rowsReturned: number;
+  /** Matched rows whose `__worker` resolved to null. */
+  rowsUnlinked: number;
+  /** Measured in-browser at commit time, 0.1ms resolution. */
+  ms: number;
+  route: Wc3AnalysisRoute;
+  /** Literal — nothing on this page is estimated. */
+  exact: true;
+  /** WC3_PROCESS_FIXTURE_NOW. */
+  asOf: string;
+  /** Flipped by analysisSaveMaterialisation, reset by any spec change. */
+  materialised: boolean;
+  /** DECLARED, not enforced — see WC3_ANALYSIS_SCOPE. */
+  scope: string;
+  lineage: string[];
+};
+/** One builder tab's live state. The result is ALWAYS the result of the spec beside it. */
+export type Wc3AnalysisModeState = {
+  spec: Wc3AnalysisSpec;
+  result: Wc3AnalysisResult;
+};
+/** Everything the perspective mutates in-session. Owned by the shell, never by a view. */
+export type Wc3AnalysisSession = {
+  object: Wc3AnalysisModeState;
+  data: Wc3AnalysisModeState;
+  saved: Wc3SavedAnalysis[];
+  materialisations: Wc3Materialisation[];
+};
+export type Wc3AnalysisViewProps = {
+  /** The LIVE session, owned by the workspace shell. Never read the fixture in a surface. */
+  session: Wc3AnalysisSession;
+  /** Commit a whole new session. Every mutation goes through this. */
+  onSessionChange: (next: Wc3AnalysisSession) => void;
+  /** Reports the drill-in segment for the shell's breadcrumb. No Analysis surface uses it today. */
+  onDetailChange?: (label: string | null) => void;
+  /** Cross-perspective / cross-tab navigation — coarse by design. */
+  onNavigate?: (target: Wc3LineageNavTarget) => void;
+};
+/** Why a result panel looks the way it does. Derived, never authored. */
+export type Wc3AnalysisDiagnosis = "ok" | "source-empty" | "no-time-column" | "filters-excluded-all" | "all-unlinked";
+/** What the workbench hands a mode-specific stage body. */
+export type Wc3AnalysisStageContext = {
+  spec: Wc3AnalysisSpec;
+  result: Wc3AnalysisResult;
+  /** Commit a spec patch: re-runs the analysis and clears `materialised`. */
+  setSpec: (patch: Partial<Wc3AnalysisSpec>) => void;
+};
+export type Wc3AnalysisWorkbenchProps = {
+  mode: Wc3AnalysisMode;
+  session: Wc3AnalysisSession;
+  onSessionChange: (next: Wc3AnalysisSession) => void;
+  onNavigate?: (target: Wc3LineageNavTarget) => void;
+  /** Source stage body — one of exactly TWO stages whose options differ per mode. */
+  renderSourceConfig: (ctx: Wc3AnalysisStageContext) => ReactNode;
+  /** Traverse / Join stage body — the other one. */
+  renderTraverseConfig: (ctx: Wc3AnalysisStageContext) => ReactNode;
+};
+/**
+ * Every user-readable string on this perspective.
+ *
+ * Verbatim from the prototype (06-unified-workspace.html, PageAnalysis / AnStageConfig / anRoute /
+ * AnResult / AnExecMeta / AnPublish / AnSavedList) EXCEPT for four entries that are marked NEW:
+ * `noTimeColumn` and `allUnlinked` close the prototype's only genuine gap (it has no state for
+ * 0 rows matched), `windowInert` states a verified fact the prototype's silence hides, and the
+ * object-mode traverse hint is rewritten because the prototype's version is false — see
+ * {@link analysisTraversalKind}.
+ */
+export declare const WC3_ANALYSIS_MESSAGES: {
+  readonly intro: {
+    readonly object: "Start from an ontology object set, traverse links, add metrics, group and chart. Object identity and permissions come from the ontology throughout.";
+    readonly data: "Start from a governed dataset or event history, join, derive and aggregate. Results can be saved as a materialisation or mapped back to an object type.";
+  };
+  readonly stageHint: {
+    readonly source: {
+      readonly object: "An ontology object set. Identity, permissions and valid traversals are defined by the object type.";
+      readonly data: "A governed dataset from the catalogue. Datasets declared but not materialised in this prototype return no rows and say so.";
+    };
+    readonly filter: "Bounded predicates evaluated before traversal. Filters narrow the set; they never widen permissions.";
+    readonly traverse: {
+      readonly object: "One ontology-declared link traversal and one plain property join. Each option below says which it is: only a traversal backed by a link type is the ontology acting as the semantic plane.";
+      readonly data: "A declared join between governed datasets.";
+    };
+    readonly derive: "Metric definitions belong to the ontology, not to this chart. A metric whose input has no materialised rows is unsupported and names what is required.";
+    readonly group: "One hierarchy level at a time. Aggregates come back as grouped rows; the full result set is never materialised in the browser.";
+    readonly viz: "Rendering reads the same grouped aggregate the engine returned. Drilling from a bar re-queries the objects behind it.";
+    readonly publish: "Every control below either mutates session state or states plainly that it is unsupported.";
+  };
+  readonly routeWhy: {
+    readonly runtime: "A selected metric depends on an input the ontology does not hold as current state. A bounded product job would have to read the governed event set, compute the metric, and write results back through an Action — it cannot be answered by either the object store or a scan of current objects.";
+    readonly analytical: (grouped: boolean) => string;
+    readonly operational: (joined: boolean) => string;
+  };
+  /**
+   * The complete reachable routing rule, stated plainly so the panel does not oversell the thesis.
+   * The Group stage offers no "none" option (faithfully, as in the prototype), so `grouped` is true
+   * for every spec this UI can produce and the traversal choice can never move the branch.
+   */
+  readonly routeLevers: "The route is computed from the spec, not chosen: any metric with a declared input requirement routes to Product Runtime; otherwise a historical window routes to Analytical and current-state-only routes to Operational. Because the Group stage always sets a grouping, the traversal and group-by choices do not move this decision — the panel does not pretend otherwise.";
+  readonly blockedMetrics: "These need presence intervals per worker. The prototype declares badge_events_import_raw in the dataset catalogue, but it has no materialised rows, so there are no badge-in/badge-out pairs to integrate into exposure hours — and a rate has no denominator without them. Required input: badge events with fld_badge_no and fld_ts landed as a governed event set. No exposure figure is shown, estimated or interpolated.";
+  readonly sourceEmpty: (dsName: string) => string;
+  /** NEW — the prototype renders a blank panel here. */
+  readonly noTimeColumn: (dsName: string, window: number, scanned: number) => string;
+  /** NEW — likewise. */
+  readonly filtersExcludedAll: (scanned: number) => string;
+  /** NEW — likewise. */
+  readonly allUnlinked: (joinKey: string) => string;
+  /**
+   * NEW, and verified by executing the engine: all 65 seeded observations fall between
+   * 2026-05-29 14:00 and 2026-07-22 06:55, i.e. inside even the 8-week window measured back from
+   * the 2026-07-22 08:00 fixture clock. Windows 0 / 8 / 26 / 56 all match the same rows and produce
+   * the same groups. Without this note the control reads as a broken filter.
+   */
+  readonly windowInert: "Changes the execution route, not the row count — every seeded row falls inside even the shortest window.";
+  readonly proofScope: (objects: number) => string;
+  readonly scopeQualifier: "declared — no row on this page is permission-filtered";
+  readonly savedEmpty: "Nothing saved yet. Saving keeps the spec, the execution route and the lineage together, so a result can always be traced back to the question that produced it.";
+  readonly resultFooter: (groups: number, matched: number) => string;
+  readonly drillThrough: (key: string, n: number) => string;
+  readonly savedToast: (name: string) => string;
+  readonly materialisedToast: (groups: number) => string;
+  readonly publish: {
+    readonly commandCentre: "A Command Center tile would bind to this saved analysis by reference, re-running it under the viewer's own permissions rather than caching one user's result. Save the analysis first to create that reference.";
+    readonly mapToObjectType: "Unsupported in this prototype. Mapping an analytical result into the ontology creates a new object type owned by a package, which is a governed package install (spec §3.2) — not a runtime write. This surface cannot author packages.";
+    readonly productRuntime: "Product Runtime would receive a reference to this governed result set, not a copy. It reads the set, computes, and writes back only through ontology Actions.";
+    readonly actionProposal: (key: string, n: number) => string;
+    readonly noGroups: "No grouped rows to propose against.";
+  };
+};
+/**
+ * Route → Badge variant. operational = low-latency current state, analytical = columnar scan,
+ * runtime = a bounded product job that does not exist yet. Theme tokens only.
+ */
+export declare const WC3_ANALYSIS_ROUTE_VARIANT: Record<Wc3AnalysisRouteId, "successSoft" | "infoSoft" | "warningSoft">;
+/**
+ * DECLARED scope, not enforced. The workspace shell has no persona switcher, so this is the default
+ * lens; no row on this page is permission-filtered and the panel says so next to it.
+ */
+export declare const WC3_ANALYSIS_SCOPE: string;
+/**
+ * Intra-perspective nav. Literals rather than an import of PERSPECTIVES, for the same reason
+ * lineageNav uses literals: it would close the cycle workspace → registry → tabs → shared →
+ * workspace. The shell guards an unknown tab id, so a rename degrades to a no-op rather than a crash.
+ */
+export declare const analysisNav: {
+  object: () => {
+    perspectiveId: string;
+    tabId: string;
+  };
+  data: () => {
+    perspectiveId: string;
+    tabId: string;
+  };
+  saved: () => {
+    perspectiveId: string;
+    tabId: string;
+  };
+};
+/**
+ * The execution engine a spec routes to. DERIVED from the shape of the query, never chosen by the
+ * user and never faked — this is the architectural point of the whole perspective: one semantic
+ * spec, three engines.
+ *
+ * Transcribed from the prototype's `anRoute`. Two things are transcribed rather than "improved":
+ *   · `needsRuntime` tests the metric's DECLARED `needs`, not the OBSERVED
+ *     `analysisMetricMissingInput`. Today both `needs` metrics are unmaterialised so the two agree;
+ *     the rule is the prototype's and stays. Materialising badge_events_import_raw would still route
+ *     to Product Runtime, which is correct — the metric is a product job either way.
+ *   · `grouped` is true for every spec this UI can produce, because the Group stage offers no "none"
+ *     option. So `joined` never actually moves the branch. See WC3_ANALYSIS_MESSAGES.routeLevers,
+ *     which the exec-meta panel renders so the surface does not imply otherwise.
+ */
+export declare function analysisRoute(spec: Wc3AnalysisSpec): Wc3AnalysisRoute;
+/**
+ * Runs ONE spec over the seeded rows and returns aggregates only — never a materialised full result
+ * set, mirroring the prototype's ObjectSetSpec/Costed&lt;T&gt; framing.
+ *
+ * MUTATION HAZARD, and the reason every step below copies: `WC3_OBSERVATION_ROWS` is not a copy of
+ * the observation rows, it is the SAME array object as `WC3_PROCESS_INSTANCES.ot_observation`. The
+ * traversal therefore builds joined rows with `{...r, __worker}` and never assigns `r.__worker`, and
+ * nothing here calls `.sort()` or `.reverse()` on a source array — only on arrays this function has
+ * just created. A single in-place write would silently change the Processes instance queue and the
+ * ontology instance counts, and it would not show up in this perspective's own tests.
+ */
+export declare function analysisRun(spec: Wc3AnalysisSpec): Wc3AnalysisResult;
+/**
+ * The provenance chain behind a result, as the exec-meta panel prints it.
+ *
+ * The object-mode middle line interpolates the traversal rather than hardcoding `reported_by`, and
+ * appends whether the ontology actually declares that traversal — because one of the two offered
+ * options is a plain property join. See {@link analysisTraversalKind}.
+ */
+export declare function analysisLineage(spec: Wc3AnalysisSpec): string[];
+/**
+ * Why a result panel looks the way it does — ordered, first match wins.
+ *
+ * This is the fix for the prototype's only genuine gap: `AnResult` handles 0 rows SCANNED but not
+ * 0 rows MATCHED, so data mode on ds_workers or ds_activities currently renders a blank result that
+ * reads as a bug. Verified: at the shipped default window of 56 weeks, ds_workers scans 290 and
+ * matches 0, ds_activities scans 230 and matches 0 — neither row table carries an observed_at
+ * column. Drop the window to 0 and ds_workers matches every row but produces ONE group,
+ * "— unlinked —", because the data-mode join key is fixed at reported_by.
+ */
+export declare function analysisDiagnose(spec: Wc3AnalysisSpec, res: Wc3AnalysisResult): Wc3AnalysisDiagnosis;
+/**
+ * Honest label for an object-mode traversal: is it an ontology-declared link, or a plain FK column
+ * the ontology says nothing about?
+ *
+ * The prototype offers `reported_by → ot_worker` and `assigned_to → ot_worker` under the hint "Only
+ * traversals the object type declares are offered". Verified against WC3_LINK_TYPES: ot_observation
+ * declares exactly TWO links — lt_obs_reporter (fkProperty reported_by, apiName reportedBy) and
+ * lt_obs_zone (fkProperty zone_id). ZERO link types reference assigned_to; it is the plain string
+ * property p_assigned_to_139. The join resolves for all 44 non-null values, so the option is worth
+ * keeping — but it is not the ontology acting as the semantic plane, and the UI must not say it is.
+ *
+ * Note the spec field is the raw FK COLUMN (`reported_by`), not the link apiName (`reportedBy`);
+ * this maps one to the other so a label can cite the link type without changing the spec vocabulary.
+ */
+export declare function analysisTraversalKind(fkProperty: string): {
+  declared: true;
+  linkTypeId: string;
+  apiName: string;
+} | {
+  declared: false;
+};
+/**
+ * The three lines the rail prints per stage — label (from WC3_ANALYSIS_STAGES), a description of
+ * what the spec says, and a count of what the run produced. Transcribed from `AnStageRail`, and
+ * derivable in full for BOTH modes.
+ *
+ * `bad` flags a stage that is the reason the result is degenerate: the prototype flags derive when a
+ * metric is unsupported and source when it holds no rows; the filter flag is added here because when
+ * a source has no time column it is the WINDOW that excluded every row, and the rail should point at
+ * the stage that did it.
+ *
+ * The `publish` entry cannot count saved analyses — that lives on the session, and this function is
+ * pure over (spec, result). The workbench fills the count in.
+ */
+export declare function analysisStageSummary(spec: Wc3AnalysisSpec, res: Wc3AnalysisResult): Record<Wc3AnalysisStageId, {
+  desc: string;
+  count: string;
+  bad: boolean;
+}>;
+/** One builder tab's live spec + result. */
+export declare function analysisModeState(s: Wc3AnalysisSession, mode: Wc3AnalysisMode): Wc3AnalysisModeState;
+/**
+ * The ONE way a spec changes. Re-runs the analysis, so the stored result is never stale, and drops
+ * `materialised` — a materialisation is a fact about one executed spec, not about the builder.
+ */
+export declare function analysisSetSpec(s: Wc3AnalysisSession, mode: Wc3AnalysisMode, patch: Partial<Wc3AnalysisSpec>): Wc3AnalysisSession;
+/**
+ * Back to the mode's default spec.
+ *
+ * The prototype resets on every MODE SWITCH, destroying the other mode's half-built query. Here the
+ * two modes are two tabs and both stay alive, so the reset is offered explicitly instead — reachable
+ * but never accidental. Documented divergence.
+ */
+export declare function analysisResetSpec(s: Wc3AnalysisSession, mode: Wc3AnalysisMode): Wc3AnalysisSession;
+/**
+ * Save the spec together with the route, the counts and the timing AS EXECUTED — which is why the
+ * result is stored beside its spec rather than re-derived: `ms` is a measurement, not a property of
+ * the spec, and a saved record must agree with what the panel showed when Save was pressed.
+ */
+export declare function analysisSaveAnalysis(s: Wc3AnalysisSession, mode: Wc3AnalysisMode): Wc3AnalysisSession;
+/** The one mutation that writes a result without touching its spec: it flips `materialised`. */
+export declare function analysisSaveMaterialisation(s: Wc3AnalysisSession, mode: Wc3AnalysisMode): Wc3AnalysisSession;
+export declare function analysisDeleteSaved(s: Wc3AnalysisSession, id: string): Wc3AnalysisSession;
+export declare function analysisDeleteMaterialisation(s: Wc3AnalysisSession, id: string): Wc3AnalysisSession;
+/** Re-open a saved analysis into ITS OWN mode's slot and re-run it. */
+export declare function analysisReopen(s: Wc3AnalysisSession, saved: Wc3SavedAnalysis): Wc3AnalysisSession;
+/**
+ * One option in a stage config body — the prototype's `.an-opt`.
+ *
+ * NEVER `disabled` when `unavailable`: selecting the unmaterialised dataset and the unsupported
+ * metric is precisely how this page demonstrates the "not materialised" and "Product Runtime"
+ * states. A disabled control would hide the two honesty demos the perspective exists to show.
+ *
+ * An unavailable option keeps the outline variant even when selected, because the amber text a
+ * `default` (primary-filled) button would carry is unreadable on a primary background; selection is
+ * signalled with a tinted background and a ring instead.
+ */
+export declare function AnalysisOption({ selected, unavailable, onSelect, children, hint }: {
+  selected: boolean;
+  unavailable?: boolean;
+  onSelect: () => void;
+  children: ReactNode;
+  /**
+   * Detail about this option. A native title rather than a paragraph under the chip: the stage
+   * panels were stacking one explanatory sentence PER OPTION, which is what made the rail scroll.
+   * Native title also avoids HoverTooltip's asChild ref requirement on a plain function component.
+   */
+  hint?: string;
+}): ReactElement;
+/** The execution route as a Badge. Two consumers: the exec-meta panel and the saved list. */
+export declare function AnalysisRouteBadge({ route }: {
+  route: Wc3AnalysisRoute | string;
+}): ReactElement;
+/**
+ * A spec rendered as labelled key/value pairs. Two consumers: the publish stage and the saved
+ * cards/table — which is what lets the saved list's card be LOSSLESS against its row.
+ */
+export declare function AnalysisSpecSummary({ spec, dense }: {
+  spec: Wc3AnalysisSpec;
+  dense?: boolean;
+}): ReactElement;
+/**
+ * THE STAGED BUILDER. Both builder tabs mount this one component and pass exactly two stage bodies —
+ * Source and Traverse / Join, the only two the prototype itself writes differently per mode. The
+ * rail, Filter, Derive, Group, Visualize, Publish, the result panel and the execution-meta panel are
+ * one implementation, which is the reason the two tabs cannot drift.
+ */
+export declare function AnalysisWorkbench({ mode, session, onSessionChange, onNavigate, renderSourceConfig, renderTraverseConfig }: Wc3AnalysisWorkbenchProps): ReactElement;
+//#endregion
+export { Mono, Pane, TypeGlyphLabel, WC3_ANALYSIS_GROUP_BYS, WC3_ANALYSIS_METRICS, WC3_ANALYSIS_SEVERITIES, WC3_ANALYSIS_SOURCE_DATASET_IDS, WC3_ANALYSIS_STAGES, WC3_ANALYSIS_WINDOWS, WC3_OBSERVATION_ROWS, WC3_WORKER_ROWS, type Wc3AnalysisFilter, type Wc3AnalysisGrain, type Wc3AnalysisGroupBy, type Wc3AnalysisJoinedRow, type Wc3AnalysisMetric, type Wc3AnalysisMode, type Wc3AnalysisRouteId, type Wc3AnalysisSpec, type Wc3AnalysisStageId, type Wc3AnalysisViz, type Wc3LineageNavTarget, type Wc3Materialisation, type Wc3SavedAnalysis, type Wc3WorkerRow, analysisDataset, analysisDatasetMaterialised, analysisDatasetName, analysisDatasetRows, analysisMetric, analysisMetricMissingInput, analysisWorker, lineageNav, wc3AnalysisDefaultSpec };
+//# sourceMappingURL=wc3-analysis-shared.d.mts.map

package/dist/pages/wc3-analysis-shared.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wc3-analysis-shared.d.mts","names":[],"sources":["../../src/pages/wc3-analysis-shared.tsx"],"mappings":";;;;;YAkFY;EAAoB,IAAI;EAAoB;EAAe;;;YAG3D;EAAoB;EAAa;EAAW,MAAM;;;YAGlD;EACX,QAAQ;;EAER,WAAW;;EAEX,SAAS;;EAET;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,OAAO;;EAEP;;EAEA;;EAEA;;EAEA;EACA;;;YAIW;EAAwB,MAAM;EAAiB,QAAQ;;;YAGvD;EACX,QAAQ;EACR,MAAM;EACN,OAAO;EACP,kBAAkB;;YAGP;;EAEX,SAAS;;EAET,kBAAkB,MAAM;;EAExB,kBAAkB;;EAElB,cAAc,QAAQ;;;YAOX;;YAGA;EACX,MAAM;EACN,QAAQ;;EAER,UAAU,OAAO,QAAQ;;YAGd;EACX,MAAM;EACN,SAAS;EACT,kBAAkB,MAAM;EACxB,cAAc,QAAQ;;EAEtB,qBAAqB,KAAK,4BAA4B;;EAEtD,uBAAuB,KAAK,4BAA4B;;;;;;;;;;;;qBAe5C;;;;;;;;;;;;;;;;;;;;;;aAiCW,aAAA;aAEA,cAAA;;;;;;;;;WAYD,cAAA;;WAGC,eAAA,gBAAM,gBAAgB;;WAGf,qBAAA;;WAGP,cAAA;;;;;;;;WAUD,aAAA;;;WAKC,eAAA,gBAAM;WAET,eAAA,aAAM;WAEP,aAAA;WACS,oBAAA;;;;;aASL,iBAAA,aAAM;;;;;;;;qBAUjB,4BAA4B,OAAO;;;;;qBAiBnC;;;;;;qBAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsBG,cAAc,MAAM,kBAAkB;;;;;;;;;;;;wBAqDtC,YAAY,MAAM,kBAAkB;;;;;;;;wBAuGpC,gBAAgB,MAAM;;;;;;;;;;;wBA+BtB,iBAAiB,MAAM,iBAAiB,KAAK,oBAAoB;;;;;;;;;;;;;;;wBA2BjE,sBACf;EACG;EAAgB;EAAoB;;EAAoB;;;;;;;;;;;;;;;wBAoB5C,qBACf,MAAM,iBACN,KAAK,oBACH,OAAO;EAAqB;EAAc;EAAe;;;wBAiE5C,kBAAkB,GAAG,oBAAoB,MAAM,kBAAkB;;;;;wBAQjE,gBACf,GAAG,oBACH,MAAM,iBACN,OAAO,QAAQ,mBACb;;;;;;;;wBAYa,kBAAkB,GAAG,oBAAoB,MAAM,kBAAkB;;;;;;wBAUjE,qBAAqB,GAAG,oBAAoB,MAAM,kBAAkB;;wBAiBpE,4BAA4B,GAAG,oBAAoB,MAAM,kBAAkB;wBAa3E,oBAAoB,GAAG,oBAAoB,aAAa;wBAIxD,8BAA8B,GAAG,oBAAoB,aAAa;;wBAKlE,eAAe,GAAG,oBAAoB,OAAO,mBAAmB;;;;;;;;;;;;wBAkBhE,iBACf,UACA,aACA,UACA,UACA;EAEA;EACA;EACA;EACA,UAAU;;;;;;EAMV;IACG;;wBAqBY,qBAAoB;EAAS,OAAO;IAA6B;;;;;wBAejE,sBAAqB,MAAM;EAAS,MAAM;EAAiB;IAAmB;;;;;;;wBA+F9E,oBACf,MACA,SACA,iBACA,YACA,oBACA,wBACE,4BAA4B"}