dabke 0.80.0 → 0.81.1

package/CHANGELOG.md

@@ -5,6 +5,59 @@ All notable changes to this project will be documented in this file.
 This changelog was generated from the git history of the project when it was
 named `scheduling-core`, prior to the rename to `dabke` in v0.78.0.
 
+## 0.81.1 (2026-02-20)
+
+### Documentation
+
+- Rewrite README for the v2 `defineSchedule` API with a verified cafe scheduling example.
+
+## 0.81.0 (2026-02-19)
+
+### Breaking Changes
+
+- **Rename employee to member**: `SchedulingEmployee` is now `SchedulingMember`,
+  `employeeIds` scope fields are now `memberIds`, and `Employee` type alias is removed.
+  The `employee-assignment-priority` rule is renamed to `assignment-priority`.
+- **Rename roleIds/skillIds to roles/skills**: on `SchedulingMember`, `ShiftPattern`,
+  and all coverage requirement types. Scope fields on rules remain `roleIds`/`skillIds`.
+- **Merge ShiftPatternDef into ShiftPattern**: the separate `ShiftPatternDef` type is
+  removed. `ShiftPattern` now directly includes `startTime`, `endTime`, and optional
+  `roles`/`skills` fields.
+- **Flatten CpsatRuleConfigEntry**: rule config entries change from
+  `{ name, config: { ... } }` to `{ name, ...config }`. Config fields sit at the same
+  level as `name`. The type is now a distributive union preventing mismatched name/config
+  pairings at compile time.
+- **Rename daysOfWeek to dayOfWeek**: on `SchedulingPeriod`, `SemanticTimeVariant`,
+  and coverage requirement types.
+- **Remove v1-only exports**: `Employee`, `ShiftPatternDef`, `defineSemanticTimes`,
+  and related types removed from the public API. Use `defineSchedule` instead.
+
+### Features
+
+- **defineSchedule API**: new primary API with composable factory functions (`time`,
+  `cover`, `shift`, rule helpers like `maxHoursPerWeek`, `timeOff`, etc.) for building
+  a complete scheduling configuration declaratively.
+- **Cost optimization**: base pay tracking (`HourlyPay`, `SalariedPay` on members),
+  cost minimization rule (`minimize-cost`), day/time cost surcharges and multipliers,
+  and post-solve cost calculation.
+- **Overtime rules**: daily and weekly overtime multipliers and surcharges,
+  tiered overtime multiplier for graduated rates.
+- **Variant coverage**: day-specific count overrides on coverage requirements
+  via `countByDay` on the `cover()` helper.
+
+### Fixes
+
+- Clean up stale solver containers on startup in the test harness.
+- Strip all entity-scope fields consistently during scope resolution.
+
+### Improvements
+
+- Simplify rule translation layer; rule-specific knowledge (schemas, defaults,
+  validation, cost) is co-located in each rule file.
+- Rewrite llms.txt generator as whitelist-based, aligned with the v2 API.
+- Enrich TSDoc throughout: schedule.ts, semantic-time.ts, coverage types,
+  and package-level documentation updated for the defineSchedule API.
+
 ## 0.80.0 (2026-02-14)
 
 ### Breaking Changes

package/README.md

@@ -4,378 +4,187 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![CI](https://github.com/christianklotz/dabke/actions/workflows/ci.yml/badge.svg)](https://github.com/christianklotz/dabke/actions/workflows/ci.yml)
 
-Scheduling library powered by constraint programming (CP-SAT).
+TypeScript scheduling library powered by constraint programming.
 
-Define your team, shifts, coverage, and rules — dabke turns them into an optimized schedule.
+Define teams, shifts, coverage, and rules declaratively. dabke compiles them into a CP-SAT model and solves for an optimized schedule.
 
 ```typescript
-import { ModelBuilder, HttpSolverClient } from "dabke";
+import {
+  defineSchedule,
+  t,
+  time,
+  cover,
+  shift,
+  maxHoursPerWeek,
+  minRestBetweenShifts,
+  timeOff,
+  minimizeCost,
+  weekdays,
+  weekend,
+} from "dabke";
+
+const schedule = defineSchedule({
+  roles: ["barista", "server"],
+
+  // Times: WHEN you need people (named periods for coverage + rules)
+  times: {
+    breakfast: time({ startTime: t(7), endTime: t(10) }),
+    lunch_rush: time(
+      { startTime: t(11, 30), endTime: t(14) },
+      { startTime: t(11), endTime: t(15), dayOfWeek: weekend },
+    ),
+    closing: time({ startTime: t(20), endTime: t(22) }),
+  },
 
-const builder = new ModelBuilder({
-  employees: [
-    { id: "alice", roleIds: ["server"] },
-    { id: "bob", roleIds: ["server"] },
+  // Coverage: HOW MANY people you need during each time
+  coverage: [
+    cover("breakfast", "barista", 1),
+    cover("lunch_rush", "barista", 2, { dayOfWeek: weekdays }),
+    cover("lunch_rush", "barista", 3, { dayOfWeek: weekend }),
+    cover("lunch_rush", "server", 1),
+    cover("closing", "server", 1),
   ],
+
+  // Shifts: WHEN people CAN work (the actual time slots)
+  // An opener covers breakfast + lunch; a closer covers lunch + closing
   shiftPatterns: [
-    { id: "morning", startTime: { hours: 8 }, endTime: { hours: 16 } },
-    { id: "evening", startTime: { hours: 16 }, endTime: { hours: 23 } },
-  ],
-  coverage: [
-    {
-      day: "2026-02-09",
-      startTime: { hours: 8 },
-      endTime: { hours: 16 },
-      roleIds: ["server"],
-      targetCount: 1,
-      priority: "MANDATORY",
-    },
-    {
-      day: "2026-02-09",
-      startTime: { hours: 16 },
-      endTime: { hours: 23 },
-      roleIds: ["server"],
-      targetCount: 1,
-      priority: "MANDATORY",
-    },
+    shift("opener", t(6), t(14)),
+    shift("mid", t(10), t(18)),
+    shift("closer", t(14), t(22)),
   ],
-  schedulingPeriod: {
-    dateRange: { start: "2026-02-09", end: "2026-02-09" },
-  },
-  ruleConfigs: [
-    { name: "max-hours-day", config: { hours: 8, priority: "MANDATORY" } },
-    { name: "min-rest-between-shifts", config: { hours: 10, priority: "MANDATORY" } },
+
+  rules: [
+    maxHoursPerWeek(40),
+    minRestBetweenShifts(11),
+    timeOff({ appliesTo: "alice", dayOfWeek: weekend }),
+    minimizeCost(),
   ],
 });
-
-const { request } = builder.compile();
-const solver = new HttpSolverClient(fetch, "http://localhost:8080");
-const response = await solver.solve(request);
 ```
 
-## Why dabke?
-
-Staff scheduling with constraint programming is dominated by Python ([OR-Tools](https://developers.google.com/optimization)) and Java ([Timefold](https://timefold.ai/)). If you're building in TypeScript, your options have been: call a Python service and figure out the model yourself, or write scheduling heuristics by hand.
-
-dabke gives you a **TypeScript-native API** for expressing scheduling problems declaratively — employees, shifts, coverage requirements, and rules — and compiles them into a CP-SAT model solved by OR-Tools. You describe _what_ you need, not _how_ to solve it.
-
-**Key differences from rolling your own:**
-
-- **Declarative rules** — express constraints like "max 8 hours/day" or "11 hours rest between shifts" as config, not code
-- **Semantic time** — define named periods ("lunch_rush", "closing") that vary by day of week
-- **Soft and hard constraints** — some rules are mandatory, others are preferences the solver optimizes for
-- **Scoped rules** — apply constraints globally, per person, per role, per skill, or during specific time periods
-- **Validation** — detailed reporting on coverage gaps and rule violations before and after solving
-
-## Install
+## Quick Start
 
 ```bash
 npm install dabke
 ```
 
-## Quick Start
-
-### 1. Start the solver
-
-dabke compiles scheduling problems into a constraint model. You need a CP-SAT solver to solve it. A ready-to-use solver is included:
+dabke compiles scheduling problems into a constraint model. You need a CP-SAT solver to find the solution:
 
 ```bash
-# Pull the solver image
 docker pull christianklotz/dabke-solver
-
-# Start it
 docker run -p 8080:8080 christianklotz/dabke-solver
 ```
 
-Or build from source:
-
-```bash
-cd node_modules/dabke/solver
-docker build -t dabke-solver .
-docker run -p 8080:8080 dabke-solver
-```
-
-### 2. Build and solve a schedule
+Once you have a schedule definition, create a config with runtime data and solve:
 
 ```typescript
 import { ModelBuilder, HttpSolverClient, parseSolverResponse, resolveAssignments } from "dabke";
 
-// Define team
-const employees = [
-  { id: "alice", roleIds: ["server"] },
-  { id: "bob", roleIds: ["server"] },
-];
-
-// Define shift patterns
-const shiftPatterns = [
-  { id: "morning", startTime: { hours: 8 }, endTime: { hours: 16 } },
-  { id: "evening", startTime: { hours: 16 }, endTime: { hours: 23 } },
-];
-
-// Define coverage requirements
-const coverage = [
-  {
-    day: "2026-02-09",
-    startTime: { hours: 8 },
-    endTime: { hours: 16 },
-    roleIds: ["server"] as [string],
-    targetCount: 1,
-    priority: "MANDATORY" as const,
-  },
-  {
-    day: "2026-02-09",
-    startTime: { hours: 16 },
-    endTime: { hours: 23 },
-    roleIds: ["server"] as [string],
-    targetCount: 1,
-    priority: "MANDATORY" as const,
-  },
-];
-
-// Build the model
-const builder = new ModelBuilder({
-  employees,
-  shiftPatterns,
-  coverage,
+const config = schedule.createSchedulerConfig({
   schedulingPeriod: {
-    dateRange: { start: "2026-02-09", end: "2026-02-09" },
+    dateRange: { start: "2026-02-09", end: "2026-02-15" },
   },
-  ruleConfigs: [
-    { name: "max-hours-day", config: { hours: 8, priority: "MANDATORY" } },
-    { name: "min-rest-between-shifts", config: { hours: 10, priority: "MANDATORY" } },
+  members: [
+    { id: "alice", roles: ["barista", "server"], pay: { hourlyRate: 1500 } },
+    { id: "bob", roles: ["barista"], pay: { hourlyRate: 1200 } },
+    { id: "carol", roles: ["barista", "server"], pay: { hourlyRate: 1400 } },
+    { id: "dave", roles: ["barista", "server"], pay: { hourlyRate: 1200 } },
+    { id: "eve", roles: ["barista", "server"], pay: { hourlyRate: 1300 } },
   ],
 });
 
-const { request, canSolve, validation } = builder.compile();
+const builder = new ModelBuilder(config);
+const { request, canSolve } = builder.compile();
 
-if (!canSolve) {
-  console.error("Cannot solve:", validation.errors);
-  process.exit(1);
-}
-
-// Solve
 const solver = new HttpSolverClient(fetch, "http://localhost:8080");
 const response = await solver.solve(request);
 const result = parseSolverResponse(response);
-
-if (result.status === "OPTIMAL" || result.status === "FEASIBLE") {
-  const shifts = resolveAssignments(result.assignments, shiftPatterns);
-  for (const shift of shifts) {
-    console.log(
-      `${shift.employeeId}: ${shift.day} ${shift.startTime.hours}:00–${shift.endTime.hours}:00`,
-    );
-  }
-}
+const shifts = resolveAssignments(result.assignments, config.shiftPatterns);
 ```
 
-## Semantic Time
-
-Define named time periods that can vary by day, then write coverage requirements in business terms:
-
-```typescript
-import { defineSemanticTimes } from "dabke";
-
-const times = defineSemanticTimes({
-  lunch: [
-    {
-      startTime: { hours: 11, minutes: 30 },
-      endTime: { hours: 14 },
-      days: ["monday", "tuesday", "wednesday", "thursday", "friday"],
-    },
-    {
-      startTime: { hours: 12 },
-      endTime: { hours: 15 },
-      days: ["saturday", "sunday"],
-    },
-  ],
-  closing: { startTime: { hours: 21 }, endTime: { hours: 23 } },
-});
-
-const coverage = times.coverage([
-  { semanticTime: "lunch", roleIds: ["server"], targetCount: 3, priority: "MANDATORY" },
-  { semanticTime: "closing", roleIds: ["server"], targetCount: 1, priority: "HIGH" },
-]);
+---
 
-// Resolve against actual scheduling days
-const days = ["2026-02-09", "2026-02-10", "2026-02-11"];
-const resolved = times.resolve(coverage, days);
-```
+## Key Concepts
 
-## Built-in Rules
+**Times vs shift patterns.** These are two distinct things. Times are named periods you need coverage for ("breakfast", "lunch_rush"). Shift patterns are the time slots people actually work ("opener 6-14", "closer 14-22"). They don't need to match. The solver assigns members to shift patterns whose hours overlap with times to satisfy coverage.
 
-| Rule                           | Description                               |
-| ------------------------------ | ----------------------------------------- |
-| `max-hours-day`                | Max hours per person per day              |
-| `max-hours-week`               | Max hours per person per week             |
-| `min-hours-day`                | Min hours per person per day              |
-| `min-hours-week`               | Min hours per person per week             |
-| `max-shifts-day`               | Max shift assignments per day             |
-| `max-consecutive-days`         | Max consecutive working days              |
-| `min-consecutive-days`         | Min consecutive working days              |
-| `min-rest-between-shifts`      | Min rest hours between shifts             |
-| `time-off`                     | Block assignments during periods          |
-| `employee-assignment-priority` | Prefer or avoid assigning team members    |
-| `assign-together`              | Keep team members on the same shifts      |
-| `location-preference`          | Prefer team members at specific locations |
+**Coverage.** How many people with which roles you need during each time. Coverage can vary by day of week or specific dates using scoping options or the variant form of `cover()`.
 
-All rules support scoping by person, role, skill, and time period (date ranges, days of week, recurring periods).
+**Rules.** Business constraints expressed as function calls. Rules with `priority: "MANDATORY"` (the default) are hard constraints the solver will never violate. Rules with `LOW`, `MEDIUM`, or `HIGH` priority are soft preferences the solver optimizes across.
 
-### Scoping Example
+**Scoping.** Every rule accepts `appliesTo` (a role, skill, or member ID), plus time scoping (`dayOfWeek`, `dateRange`, `dates`, `recurringPeriods`) to target when and who:
 
 ```typescript
-// Students can work max 4 hours on weekdays
-{
-  name: "max-hours-day",
-  config: {
-    roleIds: ["student"],
-    hours: 4,
-    dayOfWeek: ["monday", "tuesday", "wednesday", "thursday", "friday"],
-    priority: "MANDATORY",
-  },
-}
-
-// Alice has time off next week
-{
-  name: "time-off",
-  config: {
-    employeeIds: ["alice"],
-    dateRange: { start: "2026-02-09", end: "2026-02-13" },
-    priority: "MANDATORY",
-  },
-}
+maxHoursPerDay(8, { appliesTo: "barista", dayOfWeek: weekdays }),
+timeOff({ appliesTo: "alice", dateRange: { start: "2026-02-09", end: "2026-02-13" } }),
+maxHoursPerWeek(30, { appliesTo: "bob", priority: "MEDIUM" }),
 ```
 
-### Soft vs. Hard Constraints
+**Cost optimization.** Members declare `pay` as hourly or salaried. Cost rules (`minimizeCost`, `dayMultiplier`, `overtimeMultiplier`, `tieredOvertimeMultiplier`, etc.) tell the solver to minimize total labor cost, factoring in overtime, day premiums, and time-based surcharges.
 
-Rules with `priority: "MANDATORY"` are hard constraints — the solver will not violate them. Rules with `LOW`, `MEDIUM`, or `HIGH` priority are soft constraints — the solver tries to satisfy them but will trade them off against each other to find the best overall schedule.
+**Validation.** `ModelBuilder` reports coverage gaps and rule violations both pre-solve (via `compile()`) and post-solve (via `builder.reporter.analyzeSolution()`). Use `summarizeValidation()` for grouped reporting.
 
-```typescript
-// Hard: legally required rest period
-{ name: "min-rest-between-shifts", config: { hours: 11, priority: "MANDATORY" } }
+---
 
-// Soft: prefer to keep Bob under 30 hours/week
-{ name: "max-hours-week", config: { employeeIds: ["bob"], hours: 30, weekStartsOn: "monday", priority: "MEDIUM" } }
-```
+## Rules
 
-## Validation
+### Scheduling
 
-dabke validates schedules and reports coverage gaps and rule violations:
+| Function                   | Description                          |
+| -------------------------- | ------------------------------------ |
+| `maxHoursPerDay(hours)`    | Max hours per person per day         |
+| `maxHoursPerWeek(hours)`   | Max hours per person per week        |
+| `minHoursPerDay(hours)`    | Min hours per person per day         |
+| `minHoursPerWeek(hours)`   | Min hours per person per week        |
+| `maxShiftsPerDay(n)`       | Max shift assignments per day        |
+| `maxConsecutiveDays(n)`    | Max consecutive working days         |
+| `minConsecutiveDays(n)`    | Min consecutive working days         |
+| `minRestBetweenShifts(h)`  | Min rest hours between shifts        |
+| `timeOff(opts)`            | Block assignments during periods     |
+| `preference(level, opts)`  | Prefer or avoid assigning members    |
+| `preferLocation(id, opts)` | Prefer members at specific locations |
+| `assignTogether(opts)`     | Keep members on the same shifts      |
 
-```typescript
-import { ValidationReporterImpl, summarizeValidation } from "dabke";
-
-const reporter = new ValidationReporterImpl();
-const builder = new ModelBuilder({ ...config, reporter });
-const { request, validation, canSolve } = builder.compile();
-
-// Pre-solve validation
-if (!canSolve) {
-  for (const error of validation.errors) {
-    console.error(error.reason);
-  }
-}
-
-// Post-solve validation (after solving)
-reporter.analyzeSolution(response);
-const results = reporter.getValidation();
-const summaries = summarizeValidation(results);
-
-for (const s of summaries) {
-  console.log(
-    `${s.description}: ${s.status} (${s.passedCount}/${s.passedCount + s.violatedCount})`,
-  );
-}
-```
+### Cost
 
-## Custom Rules
+| Function                                 | Description                              |
+| ---------------------------------------- | ---------------------------------------- |
+| `minimizeCost()`                         | Minimize total labor cost                |
+| `dayMultiplier(factor, opts?)`           | Pay multiplier for specific days         |
+| `daySurcharge(amount, opts?)`            | Flat surcharge per hour on specific days |
+| `timeSurcharge(amount, window, opts?)`   | Surcharge during a time-of-day window    |
+| `overtimeMultiplier(opts)`               | Weekly overtime pay multiplier           |
+| `overtimeSurcharge(opts)`                | Weekly overtime flat surcharge           |
+| `dailyOvertimeMultiplier(opts)`          | Daily overtime pay multiplier            |
+| `dailyOvertimeSurcharge(opts)`           | Daily overtime flat surcharge            |
+| `tieredOvertimeMultiplier(tiers, opts?)` | Graduated overtime rates                 |
 
-dabke's rule system is extensible. You can create custom rules that integrate with the model builder:
-
-```typescript
-import { createCpsatRuleFactory, type CompilationRule } from "dabke";
-
-function createNoSundayWorkRule(config: { priority: "MANDATORY" | "HIGH" }): CompilationRule {
-  return {
-    compile(b) {
-      for (const emp of b.employees) {
-        for (const day of b.days) {
-          const date = new Date(`${day}T00:00:00Z`);
-          if (date.getUTCDay() !== 0) continue; // Sunday = 0
-          for (const pattern of b.shiftPatterns) {
-            if (!b.canAssign(emp, pattern)) continue;
-            b.addLinear([{ var: b.assignment(emp.id, pattern.id, day), coeff: 1 }], "<=", 0);
-          }
-        }
-      }
-    },
-  };
-}
-
-const customRules = createCpsatRuleFactory({
-  "no-sunday-work": createNoSundayWorkRule,
-});
-```
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for the full guide on writing custom rules.
+---
 
 ## LLM Integration
 
-dabke ships an `llms.txt` file with complete API documentation, designed for AI code generation:
+dabke ships an `llms.txt` with complete API documentation for AI code generation:
 
 ```typescript
 import { apiDocs } from "dabke/llms";
-
-// Pass to your LLM as context for generating scheduling code
 ```
 
-Or read the file directly:
-
-```bash
-cat node_modules/dabke/llms.txt
-```
+---
 
 ## Development
 
-### Running tests
-
-Unit tests have no external dependencies:
-
-```bash
-npm run test:unit
-```
-
-Integration tests require Docker to run the solver container:
-
-```bash
-# Ensure Docker is running, then:
-npm run test:integration
-```
+Unit tests (no dependencies): `npm run test:unit`
 
-The integration test harness (`startSolverContainer`) builds and starts a Docker container from `solver/Dockerfile` automatically. It binds to port 18080 by default — make sure no other container is using that port.
+Integration tests (requires Docker): `npm run test:integration`
 
-To run both unit and integration tests:
-
-```bash
-npm test          # runs typecheck + unit tests only
-npm run test:integration   # solver integration tests (requires Docker)
-```
-
-### Test utilities
-
-dabke exports test helpers for writing your own integration tests:
+The test harness builds and starts a solver container from `solver/Dockerfile` automatically.
 
 ```typescript
 import { startSolverContainer } from "dabke/testing";
-
 const solver = await startSolverContainer();
-const response = await solver.client.solve(request);
-solver.stop();
 ```
 
-This builds the solver Docker image, starts a container, waits for the health check, and returns a pre-configured `HttpSolverClient`.
-
-## Contributing
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, how to add rules, and contribution guidelines.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for how to add rules and contribute.
 
 ## License
 

package/dist/cpsat/cost.d.ts

@@ -0,0 +1,65 @@
+import type { ShiftAssignment } from "./response.js";
+import type { SchedulingMember, ShiftPattern } from "./types.js";
+import type { CompilationRule } from "./model-builder.js";
+/**
+ * Well-known cost categories used by built-in rules.
+ *
+ * Custom rules can use any string as a category. These constants
+ * are provided for convenience and consistency.
+ */
+export declare const COST_CATEGORY: {
+    /** Base pay cost (from {@link minimizeCost}). */
+    readonly BASE: "base";
+    /** Overtime cost (from overtime rules). */
+    readonly OVERTIME: "overtime";
+    /** Premium cost (from day/time multipliers and surcharges). */
+    readonly PREMIUM: "premium";
+};
+/**
+ * Per-member cost breakdown.
+ *
+ * Categories are open-ended strings. Built-in rules use categories
+ * from {@link COST_CATEGORY}. Custom rules can introduce their own.
+ */
+export interface MemberCostDetail {
+    /** Sum of all category costs. */
+    totalCost: number;
+    /** Total hours worked (computed from assignments, not from rules). */
+    totalHours: number;
+    /** Cost per category. Only categories with nonzero cost appear. */
+    categories: ReadonlyMap<string, number>;
+}
+/**
+ * Full cost breakdown for a solved schedule.
+ */
+export interface CostBreakdown {
+    /** Total cost in the caller's currency unit. */
+    total: number;
+    /** Cost per member. */
+    byMember: ReadonlyMap<string, MemberCostDetail>;
+    /** Cost per day. */
+    byDay: ReadonlyMap<string, number>;
+}
+/**
+ * Configuration accepted by {@link calculateScheduleCost}.
+ *
+ * In practice, callers pass the `ModelBuilderConfig` (which satisfies this)
+ * or the relevant subset.
+ */
+export interface CostCalculationConfig {
+    members: ReadonlyArray<SchedulingMember>;
+    shiftPatterns: ReadonlyArray<ShiftPattern>;
+    rules: ReadonlyArray<CompilationRule>;
+}
+/**
+ * Computes the actual cost of a solved schedule using the same cost model
+ * as the solver rules.
+ *
+ * Collects `CostEntry` values from all rules' `cost()` methods and
+ * aggregates them into a {@link CostBreakdown}.
+ *
+ * @param assignments - Shift assignments from {@link parseSolverResponse}
+ * @param config - Members, shift patterns, and compiled rules
+ */
+export declare function calculateScheduleCost(assignments: ShiftAssignment[], config: CostCalculationConfig): CostBreakdown;
+//# sourceMappingURL=cost.d.ts.map

package/dist/cpsat/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/cpsat/cost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAa,MAAM,oBAAoB,CAAC;AAGrE;;;;;GAKG;AACH,eAAO,MAAM,aAAa;IACxB,iDAAiD;;IAEjD,2CAA2C;;IAE3C,+DAA+D;;CAEvD,CAAC;AAEX;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAChD,oBAAoB;IACpB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACzC,aAAa,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IAC3C,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,eAAe,EAAE,EAC9B,MAAM,EAAE,qBAAqB,GAC5B,aAAa,CAuDf"}