@happyvertical/smrt-approvals 0.0.0-stage → 0.55.10

package/AGENTS.md

@@ -0,0 +1,45 @@
+# @happyvertical/smrt-approvals
+
+Decision gate plus ledger (slice 1 of #3716): `ApprovalRequest`,
+append-only `ApprovalEvent`, tighten-only `ApprovalPolicy`, and
+`ApprovalService`, the only write path. Not a workflow engine: no stages, no
+executor, no compensation. Read [agents/approvals.md](agents/approvals.md)
+before changing a transition, the guard predicates, or the surface.
+
+## Invariants
+
+- Every transition is ONE guarded `UPDATE ... WHERE id AND tenant_id AND
+  status AND version AND expires_at ... RETURNING version` plus one event
+  insert, in one transaction. Zero rows means a concurrent writer won: retry
+  from a fresh read, never write anyway. Keep the predicate the arbiter; the
+  in-transaction reads only classify refusals.
+- Only `human` principals decide; never the requester; one decision per actor
+  (unique `(request_id, vote_key)`); quorum counts distinct approver events.
+  Agents and services may request, consume, and expire.
+- Tenant: every statement names `tenant_id`, the work runs in
+  `withTenant(principal.tenantId)`, and a conflicting active context is
+  refused. Principal tenant ids must be UUIDs.
+- Policy may only tighten (`assertPolicyTightens` on write, `effectiveRules`
+  clamps on read). Quorum and expiry are fixed at request time; decide-time
+  permissions are the request snapshot plus the current kind and policy slugs.
+- Generated surface is `list`/`get` on REST and MCP, no CLI. A collection's
+  `@smrt()` config is applied to its item class by core, so each collection
+  repeats its model's surface exactly; changing one without the other opens
+  or closes the model. `surface.test.ts` holds this.
+- Models refuse re-save and delete of requests and events. Never add an
+  update path for events. Inserts need the service-only capability in
+  `src/write-capability.ts`; never export it or mint it outside the service.
+- The event FK is physical on PostgreSQL and SQLite only: DuckDB runs an
+  indexed-column UPDATE on a referenced row as delete plus insert.
+- No Node built-ins in `src/` (browser gate); use `globalThis.crypto`.
+
+## Validation
+
+```bash
+pnpm --filter @happyvertical/smrt-approvals test
+pnpm --filter @happyvertical/smrt-approvals typecheck
+pnpm --filter @happyvertical/smrt-approvals test:postgres
+```
+
+The behaviour suite (`src/__tests__/helpers/approval-suite.ts`) runs on
+SQLite, DuckDB, and, through `test:postgres`, a migrated PostgreSQL database.

package/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2025> <Happy Vertical Corporation>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,125 @@
-# Temporary Holding Version
+# @happyvertical/smrt-approvals
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A small decision gate for s-m-r-t applications. A package defines an approval
+kind; a requester opens a request bound to one revision of one subject;
+eligible people decide; the consumer consumes the approval exactly once and
+then performs its own action. It is not a workflow engine: there are no
+stages, no executor, and no compensation.
+
+## Install
+
+```bash
+pnpm add @happyvertical/smrt-approvals
+```
+
+## Concepts
+
+| Model | Purpose |
+| --- | --- |
+| `ApprovalRequest` | One gate on one subject revision: kind, subject type and id, revision hash, requester, status, quorum, expiry, decision and consumption timestamps, tenant. |
+| `ApprovalEvent` | Append-only ledger: `created`, `approved`, `rejected`, `changes_requested`, `cancelled`, `expired`, `consumed`, with actor and reason. The source of truth. |
+| `ApprovalPolicy` | A tenant's tightening of a kind: a higher quorum, a shorter expiry, or one more required permission. It can never loosen the package defaults. |
+
+Status moves from `pending` to `approved`, `rejected`, `changes_requested`,
+`cancelled`, or `expired`. An approved request is consumed once (it keeps the
+`approved` status and gains `consumedAt`) or expires unconsumed. A request
+that needs changes is finished; the requester opens a new request for the new
+revision.
+
+## Usage
+
+```typescript
+import {
+  ApprovalService,
+  defineApprovalKind,
+} from '@happyvertical/smrt-approvals';
+
+// In the owning package. Register `social.approve-post` with
+// registerPermissionDefinitions from @happyvertical/smrt-users.
+export const publishPost = defineApprovalKind({
+  key: 'social.post.publish',
+  subject: '@happyvertical/smrt-social:SocialPost',
+  permission: 'social.approve-post',
+  defaults: { requiredApprovals: 1, ttlMs: 7 * 24 * 60 * 60 * 1000 },
+});
+
+const approvals = new ApprovalService({ db });
+
+// Any principal type may request: human, agent, or service.
+const opened = await approvals.requestApproval(author, {
+  kind: publishPost,
+  subjectId: post.id,
+  subjectRevisionHash: revisionHash(post),
+  requestKey: `publish:${post.id}:${revisionHash(post)}`,
+});
+
+// Only a human of the same tenant, other than the requester, holding the
+// kind's permission, may decide, once.
+await approvals.decide(editor, opened.request.id, { decision: 'approve' });
+
+// The consumer presents the revision it is about to act on.
+const used = await approvals.consume(publisher, opened.request.id, revisionHash(post));
+if (used.outcome === 'transitioned') {
+  await publish(post);
+}
+```
+
+A principal is `{ id, tenantId, type: 'human' | 'agent' | 'service', can(slug) }`,
+built from `PermissionResolver.resolvePermissions(userId, tenantId)` in
+production or `approvalPrincipalFromPermissions()` in tests.
+
+Every transition returns `{ outcome, request, refusal? }`. `outcome` is
+`transitioned`, `already_applied` (an idempotent `requestKey` replay), or
+`refused` with a typed reason such as `not_pending`, `expired`,
+`self_approval`, `not_human`, `forbidden`, `already_decided`,
+`revision_mismatch`, `already_consumed`, `unbacked_approval`, or `not_found`. A refusal writes
+nothing.
+
+To consume inside your own transaction, so the domain write and the
+consumption commit together, pass `{ transaction: tx }` to `consume`. On
+SQLite and DuckDB open that transaction with `withEmbeddedWriteTransaction`
+from `@happyvertical/smrt-core` (or `SmrtObject.withTransaction()`), not a raw
+`db.transaction()`, so it holds the embedded write queue.
+
+Expiry: `expire(principal, id)` and `expireDue(principal)` record expiry for
+requests whose deadline passed; a job can call them. Decisions and
+consumption after the deadline are refused even before the sweep runs.
+
+## Guarantees
+
+- Every transition is one guarded conditional `UPDATE` (id, tenant, expected
+  status, version, expiry) plus one event insert in the same transaction.
+  Concurrent double approval or double consumption has exactly one winner;
+  the loser is refused cleanly and writes nothing.
+- Quorum counts distinct approvers from the ledger; one actor decides once.
+- Tenant isolation on every read and write: a request id from another tenant
+  is `not_found`.
+- The generated REST and MCP surface is `list` and `get` only, and there is no
+  generated CLI. Events cannot be updated or deleted.
+- Only `ApprovalService` can create requests and events: a row built
+  directly (`new ApprovalRequest(...)`, `ApprovalRequestCollection.create(...)`,
+  a hand-written `ApprovalEvent`) is refused at the model layer. `consume` also refuses an approval its event
+  ledger does not back (`unbacked_approval`).
+
+## Permissions
+
+| Slug | Grants |
+| --- | --- |
+| per-kind slug | Deciding requests of that kind. |
+| `approvals.cancel-any` | Cancelling someone else's pending request. |
+| `approvals.manage-policy` | Writing tenant policy (humans only). |
+
+## Development
+
+```bash
+pnpm --filter @happyvertical/smrt-approvals test
+pnpm --filter @happyvertical/smrt-approvals typecheck
+pnpm --filter @happyvertical/smrt-approvals test:postgres
+```
+
+See [AGENTS.md](./AGENTS.md) and [agents/approvals.md](./agents/approvals.md)
+for the design invariants.
+
+## License
+
+MIT

package/agents/approvals.md

@@ -0,0 +1,93 @@
+# Approvals: transitions, concurrency, and scope
+
+Design source: the accepted recommendation on smrt#3716. This file records
+the slice-1 contract (#3741) and what later slices add.
+
+## States and transitions
+
+```
+pending --approve (distinct approvers reach quorum)--> approved
+approved --consume (hash matches, unexpired)---------> approved + consumedAt
+pending --reject | request_changes-------------------> rejected | changes_requested
+pending --cancel (requester or approvals.cancel-any)-> cancelled
+pending | approved(unconsumed) --expire (deadline)---> expired
+```
+
+`changes_requested` is terminal in slice 1: the requester opens a new request
+for the new revision (a new `subjectRevisionHash`). There is no resubmit.
+
+Each transition in `src/service.ts`:
+
+1. Validates input and the principal (`id`, UUID `tenantId`, `type`, `can`).
+2. Refuses a principal whose tenant differs from an active tenant context.
+3. Opens a transaction through core's `withEmbeddedWriteTransaction(db,
+   isEmbeddedDatabase(db), fn)`. On embedded engines (SQLite, DuckDB, libsql)
+   it takes the embedded write queue for the database first, then the
+   adapter's connection lock; the event insert and change-feed append inside
+   re-enter that hold. The reverse order (a raw `db.transaction()`) deadlocks
+   against an unrelated NULL-tenant save, which holds the queue and then
+   opens its own write transaction, until the 30 s transaction-queue timeout,
+   and lets other root writes land inside the transaction. The queue also
+   serializes transitions per database, so no separate chain exists.
+   PostgreSQL is not queued: each transaction gets its own pooled connection.
+4. Reads the request through a transaction-bound collection with an explicit
+   `tenantId` filter, and classifies refusals from that read.
+5. Runs the guarded UPDATE with the version it read. Zero rows: the
+   transaction body returns `retry`, nothing was written, and the loop starts
+   again from a fresh read (up to `maxAttempts`, then `contention`).
+6. Inserts the event with `sequence` = the returned version and appends a
+   change-feed entry (the raw UPDATE bypasses save hooks).
+7. Re-reads the request after commit on the service connection.
+
+On PostgreSQL the UPDATE takes the row lock; under READ COMMITTED a waiting
+UPDATE re-evaluates `version = ?` after the winner commits, so it matches
+nothing. Unique keys `(request_id, sequence)` and `(request_id, vote_key)`
+are a second line: a violation aborts the attempt and it retries.
+
+`consume({ transaction })` runs steps 4 to 6 on the caller's open
+transaction, once, without retry or serialization; the caller owns commit.
+On embedded engines that handle must come from `withEmbeddedWriteTransaction`
+or `SmrtObject.withTransaction()`, never a raw `db.transaction()`, for the
+lock-order reason in step 3.
+
+## Raw SQL boundaries
+
+The guarded UPDATEs are the only raw SQL. They bind every value (no literal
+UUIDs or empty strings), validate the request id as a UUID first, and name
+`tenant_id`. Reads and inserts go through collections so tenancy
+interceptors, UUID columns, and the change feed behave as for any model.
+
+## Service-only write capability
+
+Only `ApprovalService` inserts `ApprovalRequest` and `ApprovalEvent` rows
+(events only in the same transaction as the guarded UPDATE they record). It passes the
+module-private `SERVICE_WRITE` symbol (`src/write-capability.ts`, not a public
+export) as a constructor option; the model records that instance in a
+`WeakSet` and refuses, in `save()` and `validateBeforeSave()`, any insert
+without it, and any minted insert that does not start pending, undecided,
+and unconsumed. `new ApprovalRequest({ status: 'approved' }).save()`,
+`ApprovalRequestCollection.create(...)`, and a forged `approved` event
+(which would otherwise count toward quorum) are refused and write nothing. A
+symbol never arrives from JSON, so REST and MCP input cannot carry it (the
+smrt-reports `runtime-report.ts` pattern). It guards the in-process API,
+not raw SQL.
+
+`consume` re-checks the ledger before consuming (defence in depth against a
+status written around the service): the `created` event at sequence 1, no
+terminal event, and `approved` events from at least `requiredApprovals`
+distinct human actors other than the requester; otherwise it refuses
+`unbacked_approval`. Quorum counting in `decide` applies the same filter.
+
+## Out of scope here (later slices of #3716)
+
+- Slice 2: Svelte inbox, panel, decision bar; `approvals.requests` recipe.
+- Slice 3: notification adapter (`UserNotificationService.notify`, sourceRef
+  `approval:<id>:<event>`), profiles `AuditLog` mirror, expiry and reminder
+  job calling `expireDue`.
+- Slice 4: adopters (social, personas, content, subscriptions).
+- Slice 5: agent and MCP request tools (deciding stays human-only).
+- Slice 6: #3667 `pending_approval` hand-off.
+
+Known gaps: listing every holder of a permission needs a users-package
+helper (for notifications); a vote stays counted if the approver later loses
+the permission.

package/dist/__smrt-register__.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=__smrt-register__.d.ts.map

package/dist/__smrt-register__.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"__smrt-register__.d.ts","sourceRoot":"","sources":["../src/__smrt-register__.ts"],"names":[],"mappings":""}

package/dist/collections/ApprovalEventCollection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Collection for {@link ApprovalEvent}. Reads only: every write goes
+ * through `ApprovalService`.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { ApprovalEvent } from '../models/ApprovalEvent.js';
+/** Tenant-scoped reads of {@link ApprovalEvent} rows. */
+export declare class ApprovalEventCollection extends SmrtCollection<ApprovalEvent> {
+    static readonly _itemClass: typeof ApprovalEvent;
+}
+//# sourceMappingURL=ApprovalEventCollection.d.ts.map

package/dist/collections/ApprovalEventCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApprovalEventCollection.d.ts","sourceRoot":"","sources":["../../src/collections/ApprovalEventCollection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAQ,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,yDAAyD;AAIzD,qBAKa,uBAAwB,SAAQ,cAAc,CAAC,aAAa,CAAC;IACxE,MAAM,CAAC,QAAQ,CAAC,UAAU,uBAAiB;CAC5C"}

package/dist/collections/ApprovalPolicyCollection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Collection for {@link ApprovalPolicy}. Reads only: every write goes
+ * through `ApprovalService`.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { ApprovalPolicy } from '../models/ApprovalPolicy.js';
+/** Tenant-scoped reads of {@link ApprovalPolicy} rows. */
+export declare class ApprovalPolicyCollection extends SmrtCollection<ApprovalPolicy> {
+    static readonly _itemClass: typeof ApprovalPolicy;
+}
+//# sourceMappingURL=ApprovalPolicyCollection.d.ts.map

package/dist/collections/ApprovalPolicyCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApprovalPolicyCollection.d.ts","sourceRoot":"","sources":["../../src/collections/ApprovalPolicyCollection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAQ,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,0DAA0D;AAI1D,qBAKa,wBAAyB,SAAQ,cAAc,CAAC,cAAc,CAAC;IAC1E,MAAM,CAAC,QAAQ,CAAC,UAAU,wBAAkB;CAC7C"}

package/dist/collections/ApprovalRequestCollection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Collection for {@link ApprovalRequest}. Reads only: every write goes
+ * through `ApprovalService`.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { ApprovalRequest } from '../models/ApprovalRequest.js';
+/** Tenant-scoped reads of {@link ApprovalRequest} rows. */
+export declare class ApprovalRequestCollection extends SmrtCollection<ApprovalRequest> {
+    static readonly _itemClass: typeof ApprovalRequest;
+}
+//# sourceMappingURL=ApprovalRequestCollection.d.ts.map

package/dist/collections/ApprovalRequestCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApprovalRequestCollection.d.ts","sourceRoot":"","sources":["../../src/collections/ApprovalRequestCollection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAQ,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE/D,2DAA2D;AAI3D,qBAKa,yBAA0B,SAAQ,cAAc,CAAC,eAAe,CAAC;IAC5E,MAAM,CAAC,QAAQ,CAAC,UAAU,yBAAmB;CAC9C"}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @happyvertical/smrt-approvals
+ *
+ * A small decision gate: a package defines an approval kind, a requester
+ * opens a request bound to one subject revision, eligible humans decide,
+ * and the consumer consumes the approval exactly once before acting.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   ApprovalService,
+ *   defineApprovalKind,
+ * } from '@happyvertical/smrt-approvals';
+ *
+ * export const publishPost = defineApprovalKind({
+ *   key: 'social.post.publish',
+ *   subject: '@happyvertical/smrt-social:SocialPost',
+ *   permission: 'social.approve-post',
+ *   defaults: { requiredApprovals: 1 },
+ * });
+ *
+ * const approvals = new ApprovalService({ db });
+ * const { request } = await approvals.requestApproval(author, {
+ *   kind: publishPost,
+ *   subjectId: post.id,
+ *   subjectRevisionHash: hashOf(post),
+ * });
+ * await approvals.decide(editor, request.id, { decision: 'approve' });
+ * const used = await approvals.consume(publisher, request.id, hashOf(post));
+ * if (used.outcome === 'transitioned') await publish(post);
+ * ```
+ *
+ * @packageDocumentation
+ */
+import './__smrt-register__.js';
+export { ApprovalEventCollection } from './collections/ApprovalEventCollection.js';
+export { ApprovalPolicyCollection } from './collections/ApprovalPolicyCollection.js';
+export { ApprovalRequestCollection } from './collections/ApprovalRequestCollection.js';
+export { type ApprovalPolicyRules, assertPolicyTightens, DEFAULT_APPROVAL_TTL_MS, defineApprovalKind, effectiveRules, getApprovalKind, listApprovalKinds, MAX_APPROVAL_TTL_MS, MAX_REQUIRED_APPROVALS, MIN_APPROVAL_TTL_MS, requireApprovalKind, unregisterApprovalKind, } from './kinds.js';
+export { ApprovalEvent, type ApprovalEventOptions, } from './models/ApprovalEvent.js';
+export { ApprovalPolicy, type ApprovalPolicyOptions, } from './models/ApprovalPolicy.js';
+export { ApprovalRequest, type ApprovalRequestOptions, } from './models/ApprovalRequest.js';
+export { APPROVAL_PERMISSION_DEFINITIONS, CANCEL_ANY_APPROVAL_PERMISSION, ensureApprovalPermissionsRegistered, MANAGE_APPROVAL_POLICY_PERMISSION, registerApprovalPermissions, } from './permissions.js';
+export { type ApprovalResult, ApprovalService, type ApprovalServiceOptions, type ConsumeOptions, type DecideInput, type RequestApprovalInput, } from './service.js';
+export { APPROVAL_EVENT_TYPES, APPROVAL_PRINCIPAL_TYPES, APPROVAL_STATUSES, type ApprovalDecision, ApprovalError, type ApprovalErrorCode, type ApprovalEventType, type ApprovalKind, type ApprovalKindDefaults, type ApprovalKindInput, type ApprovalPrincipal, type ApprovalPrincipalType, type ApprovalRefusalReason, type ApprovalStatus, type ApprovalTransitionOutcome, type ApprovalTransitionResult, approvalPrincipalFromPermissions, type EffectiveApprovalRules, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,OAAO,wBAAwB,CAAC;AAGhC,OAAO,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EACL,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,GAC1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,GAC5B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,EACnC,iCAAiC,EACjC,2BAA2B,GAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,cAAc,EACnB,eAAe,EACf,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,gCAAgC,EAChC,KAAK,sBAAsB,GAC5B,MAAM,YAAY,CAAC"}