@owlmeans/server-planning 0.1.18-rc.0

package/README.md

@@ -0,0 +1,150 @@
+# @owlmeans/server-planning
+
+The server half of `@owlmeans/planning`: the planning service and its plugin registry, the
+transition executor every write goes through, the in-memory reference store, the commit hub and the
+protocol handlers. A backend appends the service once, binds the handlers to the shared protocol
+tree, and reads and writes through a scoped facade. A browser or Node client uses
+`@owlmeans/client-planning` against the same tree; a durable store implements the ports and reuses
+the `@owlmeans/server-planning/store` subpath.
+
+## Installation
+
+```sh
+bun add @owlmeans/server-planning@^0.1.18-rc.0 @owlmeans/planning@^0.1.18-rc.0 ajv
+```
+
+## Concepts
+
+- **Facade** — `context.planning().for(scope)`: every read and write of one organization entity,
+  with no scope argument on any method.
+- **Executor** — the only write path: normalize → idempotency → resolve → plugins' `before` →
+  validate → id → code → changes → seq CAS → append → project → receipt. Nothing is appended by a
+  refusal.
+- **Plugin** — contributes types and flows, may own types with its own store, mint codes, refuse or
+  rewrite executions (`before`) and react to commits (`after`).
+- **Commit** — a transition becomes visible when a store folds it; the folding process runs the
+  `after` chain exactly once and publishes a commit event.
+- **Store** — `makeMemoryPlanningStore()` for tests and single-process tools; a durable store in
+  anything with more than one process.
+
+## Usage
+
+Declare the tree once in the shared package:
+
+```ts
+import { makePlanningProtocols } from '@owlmeans/planning'
+
+export const planningProtocols = makePlanningProtocols({
+  base: { alias: 'app:planning', path: '/planning' },
+  guards: DEFAULT_GUARD,
+})
+```
+
+Wire the service and bind the handlers:
+
+```ts
+import { appendPlanningService, servePlanningEntrypoints } from '@owlmeans/server-planning'
+
+appendPlanningService(context, { plugins: [appTypesPlugin] })
+context.registerEntrypoints(servePlanningEntrypoints(planningProtocols, {
+  scope: req => ({ channel: 'web' }),
+}))
+```
+
+Write through the facade and wait for the commit:
+
+```ts
+import { TransitionAction, WorkcardKind } from '@owlmeans/planning'
+
+const planning = context.planning().for({ entityId, profileId, channel: 'agent' })
+const { card } = await planning.execute({
+  card: { kind: WorkcardKind.Card, type: 'app:task', parent: projectId, title: 'Ship it' },
+  action: TransitionAction.Create,
+  key: `import:${sourceId}`,
+}, { wait: true })
+
+await planning.execute({ card: card!.id!, action: TransitionAction.Transit, transition: 'start' }, { wait: true })
+```
+
+A plugin with a rule and a reaction:
+
+```ts
+import { ensurePlanningService } from '@owlmeans/server-planning'
+
+ensurePlanningService(context).use({
+  name: 'app-rules',
+  order: 10,
+  before: async (exec, { card, facade }) => {
+    if (exec.transition === 'start' && await facade.cards.count({ parent: card?.parent, status: 'doing' }) > 0) {
+      throw new ProjectBusy(card!.parent!)
+    }
+  },
+  after: async (event, { transition }) => {
+    if (event.action === TransitionAction.Transit && transition?.actor.channel === 'web') {
+      await notifyWorker(event.card)
+    }
+  },
+})
+```
+
+Hand-written handler and the memory store in a test:
+
+```ts
+import { appendPlanningService, planningFor } from '@owlmeans/server-planning'
+import { makeMemoryPlanningStore } from '@owlmeans/server-planning/store'
+
+appendPlanningService(testContext, { store: makeMemoryPlanningStore({ sync: false }), plugins: [fixtures] })
+const cards = await planningFor(ctx, req, { channel: 'web' }).cards.list({ parent: projectId })
+```
+
+## API
+
+- Service: `appendPlanningService`, `ensurePlanningService`, `makePlanningService`,
+  `planningServiceApi`, `makePluginRegistry`, `makeStoreFacade`, `executeTransition`,
+  `PlanningServiceOptions`, `PlanningHostService`, `PlanningRuntime`, `PluginRegistry`
+- Handlers: `servePlanningEntrypoints`, `planningFor`, `listSchemas`, `listCards`,
+  `summarizeCards`, `getCard`, `listCardTransitions`, `listCardSpecifications`, `getSpecification`,
+  `listSpecificationRevisions`, `listLinks`, `getTransition`, `executePlanning`, `wireExecution`,
+  `executeOptionsOf`, `getCommit`, `watchCommits`, `PlanningHandlerOptions`, `PlanningScopeExtractor`
+- Scope: `scopeOf`, `actorOf`, `handlerFacade`, `planningServiceOf`, `concealed`, `assertScope`,
+  `notFoundOf`, `clampSeconds`
+- Projection: `makeProjectionProcessor`, `planningQueueHooks`, `ProjectionOptions`
+- Constants: `DEFAULT_ALIAS`, `MEMORY_STORE_ALIAS`, `DEFAULT_COMMIT_MEMORY`, `COMMIT_POLL_LADDER`
+- `@owlmeans/server-planning/store`: `makeMemoryPlanningStore`, `foldPending`, `failPending`,
+  `revisionsFromLog`, `commitEventOf`, `makeCommitHub`, `makeCompositeStore`, and the types
+  `BindablePlanningStore`, `CommitListener`, `CommitHub`, `CommitHubOptions`, `FoldOptions`,
+  `FoldResult`, `MemoryPlanningStore`, `MemoryPlanningStoreOptions`, `StoreRoute`
+
+## Common pitfalls
+
+- `after` hooks run where the transition is FOLDED, once per commit — register the same plugins in
+  every folding process, and never run hooks from a commit-bus subscription.
+- The memory store is per-process heap: wrong for multiple processes or restarts.
+- `actor` comes from the scope; a wire `actor` or `createdBy` is ignored.
+- Another entity's record is `WorkcardNotFound`, never a permission error.
+- Give retried writes a `key` — it is checked before validation, so a retry answers the first receipt.
+- `expectSeq` compares against `head`; a stale one is `WorkcardConflict`, re-read and retry.
+- Call `appendPlanningService` before any `ensurePlanningService`, or the appended host replaces
+  what was registered on the default one.
+
+## Related packages
+
+- `@owlmeans/planning` — records, flows, fold, query language, protocol tree, models
+- `@owlmeans/client-planning` — the remote facade and state mirror
+- `@owlmeans/server-job`, `@owlmeans/queue` — job feeds and the projection queue
+
+<!-- owlmeans:agent-guidance:start -->
+## Agent guidance
+
+This package ships embedded agent skills under `agent-meta/`. After installing your
+`@owlmeans/*` packages, run the OwlMeans agent-skills installer to place them into
+your project's skill store (`.agents/skills/`):
+
+```sh
+npx @owlmeans/agent-skills@^0.1.18-rc.27
+```
+
+The embedded files are version-matched to this package release. Do not edit them
+directly — they are regenerated on each publish. To contribute guidance edits,
+open a PR against the source monorepo.
+<!-- owlmeans:agent-guidance:end -->

package/agent-meta/manifest.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 2,
+  "package": "@owlmeans/server-planning",
+  "version": "0.1.18-rc.0",
+  "generatedAt": "2026-09-16T15:11:05.003Z",
+  "canonicalRepo": "https://github.com/owlmeans/common",
+  "entries": [
+    {
+      "kind": "skill",
+      "name": "server-planning",
+      "category": "package-specific",
+      "file": "skills/server-planning/SKILL.md",
+      "canonicalPath": ".agents/skills/server-planning/SKILL.md"
+    }
+  ]
+}

package/agent-meta/skills/server-planning/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: server-planning
+description: How to use @owlmeans/server-planning — appendPlanningService and the plugin registry, the transition executor and its refusal order, the in-memory store, servePlanningEntrypoints and the commit socket, and the ports a durable or foreign provider implements. Auto-invoked when wiring planning into a backend, writing a planning plugin, or diagnosing a transition that was refused or never committed.
+user-invocable: false
+---
+<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
+
+# @owlmeans/server-planning
+
+**Layer:** Server
+**Install:** `"@owlmeans/server-planning": "^0.1.18-rc.0"` in `dependencies` (`ajv` is a peer)
+
+The general implementation of `@owlmeans/planning`: the planning service (a plugin host), the
+scoped facade, the executor every write goes through, the in-memory reference store, the commit
+hub and the protocol handlers. It holds no database code — a durable store implements the ports and
+reuses the `./store` subpath (`foldPending`, `makeCommitHub`) without pulling fastify in.
+
+## Key exports
+
+| Export | What it is |
+|---|---|
+| `appendPlanningService(ctx, opts?, alias?)` | Registers the lazy host service and `ctx.planning()` |
+| `ensurePlanningService(ctx, alias?)` | Idempotent — what a plugin package calls before `use` |
+| `makePlanningService(opts?, alias?)`, `planningServiceApi(opts, self)` | The service, and its body for a specialised service |
+| `PlanningServiceOptions` | `{ store?, plugins?, schemas?, hooks?, ids?, now? }` |
+| `makePluginRegistry`, `makeStoreFacade`, `executeTransition` | The pieces the service is made of |
+| `servePlanningEntrypoints(protocols, opts?)` | One binding per protocol of a `makePlanningProtocols` tree |
+| `planningFor(ctx, req, extra?)` | The request-scoped facade for a hand-written handler |
+| `PlanningHandlerOptions` | `{ service?, event?, maxPoll?, scope?(req, ctx) }` |
+| `listCards` … `executePlanning`, `getCommit`, `watchCommits` | The handlers, to bind one by hand |
+| `scopeOf(req, extra?)`, `actorOf(req)`, `concealed(run)`, `clampSeconds` | Scope and security helpers |
+| `makeProjectionProcessor(ctx, opts?)`, `planningQueueHooks(ctx, opts?)` | A generic projection job body and its `onJobDead` |
+| `./store`: `makeMemoryPlanningStore`, `foldPending`, `failPending`, `revisionsFromLog`, `commitEventOf`, `makeCommitHub`, `makeCompositeStore` | What stores are built from |
+
+## Wiring
+
+```ts
+import { appendPlanningService, servePlanningEntrypoints } from '@owlmeans/server-planning'
+import { makePlanningProtocols } from '@owlmeans/planning'
+
+// shared package
+export const planningProtocols = makePlanningProtocols({
+  base: { alias: 'app:planning', path: '/planning', parent: appProtocols.api.base },
+  guards: DEFAULT_GUARD,
+  socketBase: appProtocols.updates.base,
+})
+
+// backend context
+appendPlanningService(context, { store: durableStore, plugins: [appTypesPlugin] })
+
+// API process
+context.registerEntrypoints(servePlanningEntrypoints(planningProtocols, {
+  scope: req => ({ channel: req.auth?.type === AuthroizationType.AuthToken ? 'connect' : 'web' }),
+}))
+```
+
+- Without `store` the service builds a memory store. The host is a LAZY service so
+  `ensurePlanningService(ctx).use(plugin)` works from `makeContext`, before `init()`.
+- Call `appendPlanningService` BEFORE any `ensurePlanningService`: `ensure` registers a default
+  host when none exists, and a later `append` replaces it together with whatever was `use`d on it.
+- In code: `ctx.planning().for({ entityId, profileId?, channel?, actor? })` → a `PlanningFacade`
+  with no scope argument on any method.
+
+## The executor, step by step
+
+Nothing is appended before step 11 — every refusal leaves the log untouched.
+
+1. **Normalize** — deep copy, trimmed text, `parents ∋ parent` (first).
+2. **Scope** — `entityId` must be present.
+3. **Idempotency** — a `key` already in the entity's log answers ITS receipt, before any
+   validation or middleware.
+4. **Resolve** — the card (`WorkcardNotFound`; another entity's card is `PlanningScopeMismatch`),
+   its type and flow, every draft parent (`ParentNotFound`) and the parent project's
+   `cardTypes`/`projectTypes` (`CardTypeNotAllowed`), the specification slot.
+5. **`before` chain** — in plugin order; re-resolved once when it changed the card, type or parent.
+6. **Validate** — shape (`planning:malformed:*`), the flow rule (`IllegalTransition`), immutables
+   (`planning:immutable:*`), merged `fields` (`FieldsInvalid`), labels (`LabelNotAllowed`), a moved
+   parent, the slot (`SpecificationSlotUnknown`, `SpecificationRevisionConflict`, JSON body schema
+   → `FieldsInvalid`), relationships (`RelationshipRefused`: undeclared type, `from` not the card,
+   missing target, type constraints, `single`, unlinking an absent edge).
+7. **Card id** — `store.newId?.() ?? options.ids?.() ?? uuid()`. Ids are the store's.
+8. **Code** — a supplied code is checked; else the plugins' `mintCode` (first answer wins, checked);
+   else the type's `CodePolicy` (a slug policy derives from the title) → `CodeTaken`.
+9. **Changes** — `computeChanges`. An `update` that changes nothing answers the card's latest
+   receipt and appends nothing.
+10. **Seq** — `transitions.nextSeq(card, expectSeq)`, a CAS against `head` (`WorkcardConflict`).
+11. **Append** — `commit: pending`. A lost race on the key answers the winner's receipt.
+12. **Project** — `store.cards.project(card)`: a sync store folds now, a queued one enqueues.
+13. **Receipt** — `{ transition, card? (once committed), committed(opts) }`.
+14. **`wait: true`** — `committed()` before returning (`CommitTimeout`, `CommitFailed`).
+
+`actor` is the SCOPE's: `profileId`/`userId`/`service`/`channel` come from the scope only; an
+in-process caller may add `agent`/`runId` on the execution. A handler never passes a wire `actor`.
+
+## Idempotency and `expectSeq`
+
+- Give every retried or replayed write a `key` (`import:<source>:<n>`). The key is unique per entity
+  and checked first, so a retry never re-validates against a card its first attempt already moved.
+- `expectSeq` compares against `head`, not `seq`: two writers racing while a fold is pending both
+  see the same `seq` but only one wins the head. `null` or omitted opts out; a model fills it from
+  its record.
+
+## The plugin seam
+
+| Concern | Rule |
+|---|---|
+| Registration | `use(plugin)` replaces by `name`; schemas are contributed at `use` time (later type/flow id wins) |
+| Order | `order ?? 50` ascending, registration order among equals |
+| Store routing | `store(type)` = the first plugin whose `owns(type)` is true AND that supplies a `store`; else the default store. A store factory is resolved once |
+| Reads | By id: the default store, then each owned store. A list naming one owned type (or several owned by one store) goes there; any other list — a cross-type query — is the default store's alone |
+| `mintCode` | First non-`undefined` answer wins |
+| `before` | Every plugin in order; may return a replaced execution; a `ResilientError` passes through, anything else becomes `PlanningRefused('<plugin>:<message>')` |
+| `after` | Every plugin in order, once per COMMITTED transition; errors logged, never rethrown |
+
+**Where `after` runs.** The service's `committed(event)` runs the chain, and it is called by the
+process that FOLDS the transition — the memory store inside `project()`, a queued store's projection
+job after marking the commit. Never subscribe a process to the commit bus to run hooks: that fires
+once per subscribed process. Every process that folds registers the same plugins; each commit is
+folded by one of them, so each hook fires once. `hooks: false` makes a process fold without running
+them. A hook sees `ctx.transition` (read back, so `actor.channel` is available) and a facade scoped
+to the event's entity acting as this process's `cfg.service`.
+
+The service hands `committed` to a store through `store.bind?.(listener)` the first time it resolves
+the store; `bind` replaces the listener, so a store has exactly one.
+
+## The memory store
+
+`makeMemoryPlanningStore({ sync?, ids?, now?, seed?, onCommitted?, alias? })`
+
+- Cards and projects in one map, specifications in their own, relationships in a third; every read
+  goes through the `@owlmeans/resource` query engine. A card list includes specifications only when
+  the criteria asks for `kind: specification` or a `category`.
+- `sync` (default) folds, publishes and runs `committed` inside `project()`, serialized per card.
+  `sync: false` folds nothing until `flush(card?)` — a queued store's shape, for tests that need a
+  commit to stay pending.
+- A project `delete` purges the project, everything whose `parents` reach it, their specifications,
+  links and log; the commit hub remembers the settled event so the waiter still gets its answer.
+- **It is wrong for more than one process or a restart** — the log, the cards and the commit feed
+  are this process's heap. Use it for tests, tools and single-process demos.
+
+## Writing a durable store
+
+- Implement `PlanningStore` (`transitions`, `cards`, `specs`, `links`, `commits`, `newId`). `newId`
+  answers the id format the host's references need (ObjectId hex for Mongo).
+- `transitions.list` treats `sinceSeq` as `seq > sinceSeq`; `nextSeq` is the CAS against `head` and
+  answers 1 for a card that has no log.
+- The projection body is `foldPending(store, cardId, entityId, { onCommitted, publish, touch, limit })`:
+  it applies pending transitions with `applyTransition` only, marks each committed or failed,
+  publishes, then runs `onCommitted`. The caller owns single flight per card. Strip `record` from
+  the event before a cross-process bus.
+- **A failed transition never blocks the card.** The fold marks it `failed`, publishes a failed
+  event, and goes PAST it: the card's `seq` advances to that transition with every other value as
+  it was, and the next transition folds normally. Without that, every later transition fails as
+  out of order and the card is stuck for good. Only two cases stop short: a failed `create` leaves
+  no card to advance, and a store that refuses the advancing write stops the fold with `followUp`,
+  leaving the rest pending for a retry. `revisionsFromLog` replays past failed transitions the same
+  way.
+- `failPending` is what a dead projection job must do, or waiters hang to their timeout.
+- `makeCommitHub({ status, remember?, ladder? })` is the `CommitSource`: feed `publish` from the bus,
+  answer `status` from transition rows. `wait` subscribes first, polls once, then climbs the ladder.
+- `revisionsFromLog(transitions, limit?)` answers `specs.revisions`.
+- `makeProjectionProcessor(ctx)` + `planningQueueHooks(ctx)` are the store-agnostic job body and
+  `onJobDead`; a store with an admission CAS wraps its own around them.
+
+## A foreign provider
+
+Only `cards` is required. A plugin that `owns` its types and supplies a store without
+`transitions` can be read through the facade; writes to it refuse with `PlanningUnsupported` —
+mapping external records (`mappers`) belongs to that plugin's own store adapter.
+
+## The commit feed
+
+- **Poll** — `commit.get` answers the status; with `?wait=<s>` (clamped to `maxPoll`, default 55)
+  it subscribes, re-polls, and holds until the commit settles or the time is up, answering `pending`
+  then — never an error.
+- **Notify** — `commit.events` pushes `planning-commit` frames (or `opts.event`) filtered by the
+  authenticated entity and optional `project`/`card` query values; a frame without `record` gets the
+  card as it reads now. The subscription is released on the socket's `close` frame.
+- `execute` with `wait: true` holds at most `maxPoll` seconds whatever `timeout` the body asked for.
+
+## Scope and security
+
+- `entityId` is `requireEntityKey(req)`; `opts.scope(req, ctx)` adds a `channel` or `service` and
+  can never replace the entity. `actor` and a create's `createdBy` come from the request, never the
+  body.
+- Another entity's card, specification or transition answers `WorkcardNotFound` — the same as an
+  absent id — on reads and writes alike (`concealed`).
+- Queries arrive in their wire form and are decoded with `decode*Query` before `criteriaOf`, which
+  always adds the scope's `entityId`.
+
+## Testing
+
+Category A. Build one real context with `makeBasicContext` + `appendPlanningService({ store:
+makeMemoryPlanningStore({ now }), plugins: [fixtures] })`, and run a handler through
+`handler.bind({ ref: { ctx } })(req, res)` with a request carrying `auth` and `entity`. A monotonic
+`now` keeps log order deterministic; `sync: false` + `flush()` pins pending and hook-count cases.
+
+## Related
+
+- `planning` — records, flows, the fold, the query language, the protocol tree, the models
+- `client-planning` — the remote facade and the state mirror that talk to these handlers
+- `server-job`, `queue` — the declare/serve/feed pattern and the projection queue
+- `resource` — the criteria engine every memory read goes through

package/build/actions/cards.d.ts

@@ -0,0 +1,16 @@
+import { handlers } from '@owlmeans/server-api';
+import type { PlanningProtocols } from '@owlmeans/planning';
+import type { Context, PlanningHandlerOptions } from '../types.js';
+type RequestHandler = ReturnType<ReturnType<typeof handlers<Context>>['request']>;
+/** Cards of the caller's entity; the query arrives in its wire shape and is decoded here. */
+export declare const listCards: (protocol: PlanningProtocols['card']['list'], opts?: PlanningHandlerOptions) => RequestHandler;
+/** Intrinsic counts of DIRECT children per parent. */
+export declare const summarizeCards: (protocol: PlanningProtocols['card']['summary'], opts?: PlanningHandlerOptions) => RequestHandler;
+/** @throws {WorkcardNotFound} for an absent card and for another entity's alike */
+export declare const getCard: (protocol: PlanningProtocols['card']['get'], opts?: PlanningHandlerOptions) => RequestHandler;
+/** One card's log. */
+export declare const listCardTransitions: (protocol: PlanningProtocols['card']['transitions'], opts?: PlanningHandlerOptions) => RequestHandler;
+/** One card's specifications — the current document per category unless `all`. */
+export declare const listCardSpecifications: (protocol: PlanningProtocols['card']['specifications'], opts?: PlanningHandlerOptions) => RequestHandler;
+export {};
+//# sourceMappingURL=cards.d.ts.map

package/build/actions/cards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cards.d.ts","sourceRoot":"","sources":["../../src/actions/cards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAI/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlE,KAAK,cAAc,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAA;AAEjF,6FAA6F;AAC7F,eAAO,MAAM,SAAS,aAAc,iBAAiB,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,SAAS,sBAAsB,KAAG,cAKlG,CAAA;AAEL,sDAAsD;AACtD,eAAO,MAAM,cAAc,aAAc,iBAAiB,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,sBAAsB,KAAG,cAM1G,CAAA;AAEL,mFAAmF;AACnF,eAAO,MAAM,OAAO,aAAc,iBAAiB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,SAAS,sBAAsB,KAAG,cAK/F,CAAA;AAEL,sBAAsB;AACtB,eAAO,MAAM,mBAAmB,aAAc,iBAAiB,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,SAAS,sBAAsB,KAAG,cAMnH,CAAA;AAEL,kFAAkF;AAClF,eAAO,MAAM,sBAAsB,aAAc,iBAAiB,CAAC,MAAM,CAAC,CAAC,gBAAgB,CAAC,SAAS,sBAAsB,KAAG,cAMzH,CAAA"}

package/build/actions/cards.js

@@ -0,0 +1,32 @@
+import { handlers } from '@owlmeans/server-api';
+import { decodeSpecificationQuery, decodeSummaryQuery, decodeTransitionQuery, decodeWorkcardQuery, } from '@owlmeans/planning';
+import { concealed, handlerFacade } from '../utils/index.js';
+/** Cards of the caller's entity; the query arrives in its wire shape and is decoded here. */
+export const listCards = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    return await facade.cards.list(decodeWorkcardQuery(req.query));
+}));
+/** Intrinsic counts of DIRECT children per parent. */
+export const summarizeCards = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    const { parents, ...query } = decodeSummaryQuery(req.query);
+    return await facade.cards.summary(parents, query);
+}));
+/** @throws {WorkcardNotFound} for an absent card and for another entity's alike */
+export const getCard = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    return await facade.cards.get(`${req.params.id}`);
+}));
+/** One card's log. */
+export const listCardTransitions = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    const card = await facade.cards.get(`${req.params.id}`);
+    return await facade.transitions.list({ ...decodeTransitionQuery(req.query), card: card.id });
+}));
+/** One card's specifications — the current document per category unless `all`. */
+export const listCardSpecifications = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    const card = await facade.cards.get(`${req.params.id}`);
+    return await facade.specifications.list(card.id, decodeSpecificationQuery(req.query));
+}));
+//# sourceMappingURL=cards.js.map

package/build/actions/cards.js.map

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

package/build/actions/commit.d.ts

@@ -0,0 +1,14 @@
+import { handlers } from '@owlmeans/server-api';
+import type { PlanningProtocols } from '@owlmeans/planning';
+import type { Context, PlanningHandlerOptions } from '../types.js';
+/**
+ * The poll tool: a commit's status, held open up to `wait` seconds (clamped to `maxPoll`).
+ *
+ * status → settled or no wait: answer → subscribe → poll again (a commit landing between the two
+ * reads is caught by the subscription) → race the subscription against the timer → answer the
+ * status as it is then, still `pending` when nothing landed.
+ *
+ * @throws {WorkcardNotFound} for another entity's transition
+ */
+export declare const getCommit: (protocol: PlanningProtocols['commit']['get'], opts?: PlanningHandlerOptions) => ReturnType<ReturnType<typeof handlers<Context>>['request']>;
+//# sourceMappingURL=commit.d.ts.map

package/build/actions/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/actions/commit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlE;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,aACV,iBAAiB,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,SAAS,sBAAsB,KAC1E,UAAU,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAqCxD,CAAA"}

package/build/actions/commit.js

@@ -0,0 +1,48 @@
+import { handlers } from '@owlmeans/server-api';
+import { CommitState, MAX_COMMIT_POLL } from '@owlmeans/planning';
+import { clampSeconds, concealed, handlerFacade } from '../utils/index.js';
+/**
+ * The poll tool: a commit's status, held open up to `wait` seconds (clamped to `maxPoll`).
+ *
+ * status → settled or no wait: answer → subscribe → poll again (a commit landing between the two
+ * reads is caught by the subscription) → race the subscription against the timer → answer the
+ * status as it is then, still `pending` when nothing landed.
+ *
+ * @throws {WorkcardNotFound} for another entity's transition
+ */
+export const getCommit = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    const transition = `${req.params.transition}`;
+    let status = await facade.commits.status(transition);
+    const wait = clampSeconds(req.query?.wait, opts?.maxPoll ?? MAX_COMMIT_POLL);
+    if (status.state !== CommitState.Pending || wait <= 0) {
+        return status;
+    }
+    let landed = false;
+    let wake = () => { landed = true; };
+    const unsubscribe = await facade.commits.subscribe(event => {
+        if (event.transition === transition && event.state !== CommitState.Pending) {
+            wake();
+        }
+    });
+    try {
+        status = await facade.commits.status(transition);
+        if (status.state === CommitState.Pending) {
+            if (!landed) {
+                await new Promise(resolve => {
+                    const timer = setTimeout(resolve, wait * 1000);
+                    wake = () => {
+                        clearTimeout(timer);
+                        resolve();
+                    };
+                });
+            }
+            status = await facade.commits.status(transition);
+        }
+    }
+    finally {
+        unsubscribe();
+    }
+    return status;
+}));
+//# sourceMappingURL=commit.js.map

package/build/actions/commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","sourceRoot":"","sources":["../../src/actions/commit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAGjE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAE1E;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,QAA4C,EAAE,IAA6B,EACd,EAAE,CAC/D,QAAQ,EAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,IAA2B,EAAE;IACpG,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;IAClD,MAAM,UAAU,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,CAAA;IAE7C,IAAI,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;IACpD,MAAM,IAAI,GAAG,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,IAAI,eAAe,CAAC,CAAA;IAC5E,IAAI,MAAM,CAAC,KAAK,KAAK,WAAW,CAAC,OAAO,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;QACtD,OAAO,MAAM,CAAA;IACf,CAAC;IAED,IAAI,MAAM,GAAG,KAAK,CAAA;IAClB,IAAI,IAAI,GAAe,GAAG,EAAE,GAAG,MAAM,GAAG,IAAI,CAAA,CAAC,CAAC,CAAA;IAC9C,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;QACzD,IAAI,KAAK,CAAC,UAAU,KAAK,UAAU,IAAI,KAAK,CAAC,KAAK,KAAK,WAAW,CAAC,OAAO,EAAE,CAAC;YAC3E,IAAI,EAAE,CAAA;QACR,CAAC;IACH,CAAC,CAAC,CAAA;IACF,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAChD,IAAI,MAAM,CAAC,KAAK,KAAK,WAAW,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,OAAO,CAAO,OAAO,CAAC,EAAE;oBAChC,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC,CAAA;oBAC9C,IAAI,GAAG,GAAG,EAAE;wBACV,YAAY,CAAC,KAAK,CAAC,CAAA;wBACnB,OAAO,EAAE,CAAA;oBACX,CAAC,CAAA;gBACH,CAAC,CAAC,CAAA;YACJ,CAAC;YACD,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAClD,CAAC;IACH,CAAC;YAAS,CAAC;QACT,WAAW,EAAE,CAAA;IACf,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC,CAAC,CAAC,CAAA"}

package/build/actions/execute.d.ts

@@ -0,0 +1,13 @@
+import { handlers } from '@owlmeans/server-api';
+import type { ExecuteOptions, ExecuteRequest, PlanningProtocols, PlanningScope, TransitionExecution } from '@owlmeans/planning';
+import type { Context, PlanningHandlerOptions } from '../types.js';
+/**
+ * What a wire execution may say. `actor` is dropped — the scope names the writer — and a create's
+ * `createdBy` is the authenticated subject, whatever the body claimed.
+ */
+export declare const wireExecution: (body: ExecuteRequest, scope: PlanningScope) => TransitionExecution;
+/** `wait`/`timeout` as a server grants them: the timeout never holds a request past `maxPoll`. */
+export declare const executeOptionsOf: (body: Pick<ExecuteRequest, 'wait' | 'timeout'>, maxPoll: number) => ExecuteOptions;
+/** The one write route. */
+export declare const executePlanning: (protocol: PlanningProtocols['execute'], opts?: PlanningHandlerOptions) => ReturnType<ReturnType<typeof handlers<Context>>['request']>;
+//# sourceMappingURL=execute.d.ts.map

package/build/actions/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/actions/execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,OAAO,KAAK,EACV,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EACtF,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlE;;;GAGG;AACH,eAAO,MAAM,aAAa,SAAU,cAAc,SAAS,aAAa,KAAG,mBAQ1E,CAAA;AAED,kGAAkG;AAClG,eAAO,MAAM,gBAAgB,SAAU,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC,WAAW,MAAM,KAAG,cAOlG,CAAA;AAED,2BAA2B;AAC3B,eAAO,MAAM,eAAe,aAChB,iBAAiB,CAAC,SAAS,CAAC,SAAS,sBAAsB,KACpE,UAAU,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAWxD,CAAA"}

package/build/actions/execute.js

@@ -0,0 +1,35 @@
+import { handlers } from '@owlmeans/server-api';
+import { DEFAULT_COMMIT_TIMEOUT, MAX_COMMIT_POLL, TransitionAction } from '@owlmeans/planning';
+import { concealed, handlerFacade } from '../utils/index.js';
+/**
+ * What a wire execution may say. `actor` is dropped — the scope names the writer — and a create's
+ * `createdBy` is the authenticated subject, whatever the body claimed.
+ */
+export const wireExecution = (body, scope) => {
+    const { wait: _wait, timeout: _timeout, actor: _actor, ...exec } = body;
+    if (exec.action === TransitionAction.Create && exec.card != null && typeof exec.card === 'object') {
+        const { createdBy: _createdBy, ...draft } = exec.card;
+        const subject = scope.profileId ?? scope.userId;
+        exec.card = subject != null ? { ...draft, createdBy: subject } : draft;
+    }
+    return exec;
+};
+/** `wait`/`timeout` as a server grants them: the timeout never holds a request past `maxPoll`. */
+export const executeOptionsOf = (body, maxPoll) => {
+    const ceiling = maxPoll * 1000;
+    if (body.wait !== true) {
+        return {};
+    }
+    const asked = Number(body.timeout ?? DEFAULT_COMMIT_TIMEOUT);
+    return { wait: true, timeout: Math.min(Number.isFinite(asked) && asked > 0 ? asked : DEFAULT_COMMIT_TIMEOUT, ceiling) };
+};
+/** The one write route. */
+export const executePlanning = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    const body = (req.body ?? {});
+    const receipt = await facade.execute(wireExecution(body, facade.scope), executeOptionsOf(body, opts?.maxPoll ?? MAX_COMMIT_POLL));
+    return receipt.card !== undefined
+        ? { transition: receipt.transition, card: receipt.card }
+        : { transition: receipt.transition };
+}));
+//# sourceMappingURL=execute.js.map

package/build/actions/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.js","sourceRoot":"","sources":["../../src/actions/execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAK9F,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAE5D;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAoB,EAAE,KAAoB,EAAuB,EAAE;IAC/F,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAA;IACvE,IAAI,IAAI,CAAC,MAAM,KAAK,gBAAgB,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAClG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC,IAAI,CAAA;QACrD,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,CAAA;QAC/C,IAAI,CAAC,IAAI,GAAG,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;IACxE,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AAED,kGAAkG;AAClG,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAA8C,EAAE,OAAe,EAAkB,EAAE;IAClH,MAAM,OAAO,GAAG,OAAO,GAAG,IAAI,CAAA;IAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACvB,OAAO,EAAE,CAAA;IACX,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,sBAAsB,CAAC,CAAA;IAC5D,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,sBAAsB,EAAE,OAAO,CAAC,EAAE,CAAA;AACzH,CAAC,CAAA;AAED,2BAA2B;AAC3B,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,QAAsC,EAAE,IAA6B,EACR,EAAE,CAC/D,QAAQ,EAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,IAAoC,EAAE;IAC7G,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;IAClD,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAmB,CAAA;IAC/C,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,CAClC,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,IAAI,eAAe,CAAC,CAC5F,CAAA;IAED,OAAO,OAAO,CAAC,IAAI,KAAK,SAAS;QAC/B,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE;QACxD,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAA;AACxC,CAAC,CAAC,CAAC,CAAA"}

package/build/actions/index.d.ts

@@ -0,0 +1,9 @@
+export * from './cards.js';
+export * from './commit.js';
+export * from './execute.js';
+export * from './links.js';
+export * from './schemas.js';
+export * from './specs.js';
+export * from './transitions.js';
+export * from './watch.js';
+//# sourceMappingURL=index.d.ts.map

package/build/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA"}

package/build/actions/index.js

@@ -0,0 +1,9 @@
+export * from './cards.js';
+export * from './commit.js';
+export * from './execute.js';
+export * from './links.js';
+export * from './schemas.js';
+export * from './specs.js';
+export * from './transitions.js';
+export * from './watch.js';
+//# sourceMappingURL=index.js.map

package/build/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA"}

package/build/actions/links.d.ts

@@ -0,0 +1,5 @@
+import { handlers } from '@owlmeans/server-api';
+import type { PlanningProtocols } from '@owlmeans/planning';
+import type { Context, PlanningHandlerOptions } from '../types.js';
+export declare const listLinks: (protocol: PlanningProtocols['link']['list'], opts?: PlanningHandlerOptions) => ReturnType<ReturnType<typeof handlers<Context>>['request']>;
+//# sourceMappingURL=links.d.ts.map

package/build/actions/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/actions/links.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlE,eAAO,MAAM,SAAS,aACV,iBAAiB,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,SAAS,sBAAsB,KACzE,UAAU,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAKxD,CAAA"}

package/build/actions/links.js

@@ -0,0 +1,8 @@
+import { handlers } from '@owlmeans/server-api';
+import { decodeRelationshipQuery } from '@owlmeans/planning';
+import { concealed, handlerFacade } from '../utils/index.js';
+export const listLinks = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
+    const facade = await handlerFacade(ctx, req, opts);
+    return await facade.relationships.list(decodeRelationshipQuery(req.query));
+}));
+//# sourceMappingURL=links.js.map

package/build/actions/links.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.js","sourceRoot":"","sources":["../../src/actions/links.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAG5D,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAE5D,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,QAA2C,EAAE,IAA6B,EACb,EAAE,CAC/D,QAAQ,EAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;IAC7E,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;IAElD,OAAO,MAAM,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AAC5E,CAAC,CAAC,CAAC,CAAA"}

package/build/actions/schemas.d.ts

@@ -0,0 +1,6 @@
+import { handlers } from '@owlmeans/server-api';
+import type { PlanningProtocols } from '@owlmeans/planning';
+import type { Context, PlanningHandlerOptions } from '../types.js';
+/** The schema bundle the service holds — what a client loads to answer `can()` with no round trip. */
+export declare const listSchemas: (protocol: PlanningProtocols['schema']['list'], opts?: PlanningHandlerOptions) => ReturnType<ReturnType<typeof handlers<Context>>['request']>;
+//# sourceMappingURL=schemas.d.ts.map

package/build/actions/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/actions/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlE,sGAAsG;AACtG,eAAO,MAAM,WAAW,aACZ,iBAAiB,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,sBAAsB,KAC3E,UAAU,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAMzD,CAAA"}