@owlmeans/server-planning 0.1.18-rc.21 → 0.1.18-rc.22

package/README.md

@@ -10,7 +10,7 @@ the `@owlmeans/server-planning/store` subpath.
 ## Installation
 
 ```sh
-bun add @owlmeans/server-planning@^0.1.18-rc.21 @owlmeans/planning@^0.1.18-rc.18 ajv
+bun add @owlmeans/server-planning@^0.1.18-rc.22 @owlmeans/planning@^0.1.18-rc.19 ajv
 ```
 
 ## Concepts
@@ -93,39 +93,46 @@ ensurePlanningService(context).use({
 Hand-written handler and the memory store in a test:
 
 ```ts
-import { appendPlanningService, planningFor } from '@owlmeans/server-planning'
+import { appendPlanningService, planningHandlerOf } 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 })
+const cards = await planningHandlerOf(ctx).planningFor(req, { channel: 'web' }).cards.list({ parent: projectId })
 ```
 
 ## API
 
 - Service: `appendPlanningService`, `ensurePlanningService`, `makePlanningService`,
   `planningServiceApi`, `makePluginRegistry`, `makeStoreFacade`, `executeTransition`,
-  `creatorOf`, `withCreator`, `assertCreatorFixed`, `PlanningServiceOptions`, `PlanningHostService`,
+  `creatorHelper` (`creatorOf`, `withCreator`, `assertCreatorFixed`), `PlanningServiceOptions`, `PlanningHostService`,
   `PlanningRuntime`, `PluginRegistry`
-- Handlers: `servePlanningEntrypoints`, `planningFor`, `listSchemas`, `listCards`,
+- Handlers (one per file under `actions/`): `servePlanningEntrypoints`, `listSchemas`, `listCards`,
   `summarizeCards`, `getCard`, `listCardTransitions`, `listCardSpecifications`, `getSpecification`,
-  `listSpecificationRevisions`, `listLinks`, `getTransition`, `executePlanning`, `wireExecution`,
-  `executeOptionsOf`, `assertExecutionGranted`, `getCommit`, `watchCommits`, `defineSchemas`,
-  `applySchemaRequest`, `PlanningHandlerOptions`, `PlanningScopeExtractor`, `PlanningAccessResolver`,
-  `PlanningAccess`, `PlanningAccessGrants`, `PlanningGrant`
-- Scope: `scopeOf`, `accessScopeOf`, `actorOf`, `handlerFacade`, `handlerScopeOf`, `assertGranted`,
-  `planningServiceOf`, `concealed`, `assertScope`, `notFoundOf`, `clampSeconds`, `projectCriteriaOf`
+  `listSpecificationRevisions`, `listLinks`, `getTransition`, `executePlanning`, `getCommit`,
+  `watchCommits`, `defineSchemas`, `applySchemaRequest`; `executionHelper` (`wireExecution`,
+  `executeOptionsOf`, `assertExecutionWrites`, `assertExecutionGranted`); `PlanningHandlerOptions`,
+  `PlanningScopeExtractor`, `PlanningAccessResolver`, `PlanningAccess`, `PlanningAccessGrants`,
+  `PlanningGrant`
+- Scope: `planningHandlerOf(ctx)` (`planningServiceOf`, `handlerScopeOf`, `handlerFacade`,
+  `planningFor`), `makeRequestScope(req)` (`scopeOf`, `accessScopeOf`, `actorOf`),
+  `makePlanningAccessModel(access)` (`assertGranted`, `writableIn`, `assertWrites`), `guardHelper`
+  (`concealed`, `assertScope`, `notFoundOf`, `clampSeconds`), `projectCriteriaOf`
 - Data-defined schemas: `makeDefinitions`, `makeSchemaViews`, `SchemaViews`, `SchemaViewsOptions`
-- Projection: `makeProjectionProcessor`, `planningQueueHooks`, `ProjectionOptions`
+- Projection: `makeProjectionProcessor`, `makePlanningQueueHooks`, `ProjectionOptions`
 - Constants: `DEFAULT_ALIAS`, `MEMORY_STORE_ALIAS`, `DEFAULT_COMMIT_MEMORY`, `COMMIT_POLL_LADDER`,
   `DEFAULT_SCHEMA_VIEWS`
-- `@owlmeans/server-planning/store`: `makeMemoryPlanningStore`, `foldPending`, `failPending`,
-  `revisionsFromLog`, `commitEventOf`, `makeCommitHub`, `makeCompositeStore`, `wantsSpecifications`,
+- `@owlmeans/server-planning/store`: `makeMemoryPlanningStore`, `foldHelper` (`foldPending`,
+  `failPending`, `revisionsFromLog`, `commitEventOf`), `makeCommitHub`, `makeCompositeStore`,
+  `wantsSpecifications`,
   and the types `BindablePlanningStore`, `CommitListener`, `CommitHub`, `CommitHubOptions`,
   `FoldOptions`, `FoldResult`, `MemoryPlanningStore`, `MemoryPlanningStoreOptions`, `StoreRoute`
 - `@owlmeans/server-planning/conformance`: `planningConformance`, `conformanceCasesFor`,
-  `planningConformancePlugin`, `conformanceClock`, `ConformanceFailure`, `check`, `same`,
-  `sameSet`, `rejects`, the library fixtures (`LIBRARY`, `createBranch`, `createBook`, `transit`)
+  `planningConformancePlugin`, `conformanceClock`, `ConformanceFailure`, `assertHelper` (`check`,
+  `same`, `sameSet`, `rejects`), the library fixtures (`LIBRARY`, `conformanceFixturesOf(facade)` —
+  `createBranch`, `createBook`, `transit`)
   and the types `ConformanceCase`, `ConformanceSubject`, `ConformanceCapability`
+- The former plain functions (`planningFor`, `foldPending`, `creatorOf`, `scopeOf`, `concealed`,
+  `planningQueueHooks`, `check`, `createBranch`, …) remain as deprecated delegates.
 
 ## Common pitfalls
 
@@ -169,7 +176,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.48
+npx @owlmeans/agent-skills@^0.1.18-rc.49
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/server-planning",
-  "version": "0.1.18-rc.21",
-  "generatedAt": "2026-10-05T08:32:19.088Z",
+  "version": "0.1.18-rc.22",
+  "generatedAt": "2026-10-05T21:03:06.363Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

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

@@ -8,12 +8,12 @@ user-invocable: false
 # @owlmeans/server-planning
 
 **Layer:** Server
-**Install:** `"@owlmeans/server-planning": "^0.1.18-rc.21"` in `dependencies` (`ajv` is a peer)
+**Install:** `"@owlmeans/server-planning": "^0.1.18-rc.22"` 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.
+reuses the `./store` subpath (`foldHelper.foldPending`, `makeCommitHub`) without pulling fastify in.
 
 ## Key exports
 
@@ -24,17 +24,17 @@ reuses the `./store` subpath (`foldPending`, `makeCommitHub`) without pulling fa
 | `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 |
-| `creatorOf(scope)`, `withCreator(exec, scope)`, `assertCreatorFixed(exec)` | The subject a create is stamped with as `createdBy`, the defaulting the executor applies, and its refusal of any later move |
+| `creatorHelper` — `.creatorOf(scope)`, `.withCreator(exec, scope)`, `.assertCreatorFixed(exec)` | The subject a create is stamped with as `createdBy`, the defaulting the executor applies, and its refusal of any later move |
 | `servePlanningEntrypoints(protocols, opts?)` | One binding per protocol of a `makePlanningProtocols` tree (`schema.define` too when declared) |
-| `planningFor(ctx, req, extra?)` | The request-scoped facade for a hand-written handler |
+| `planningHandlerOf(ctx).planningFor(req, extra?)` | The request-scoped facade for a hand-written handler |
 | `PlanningHandlerOptions` | `{ service?, event?, maxPoll?, scope?(req, ctx), access?(req, ctx) }` |
 | `PlanningAccessResolver`, `PlanningAccess`, `PlanningAccessGrants`, `PlanningGrant` | The optional access decision a hosting app supplies |
 | `listCards` … `executePlanning`, `getCommit`, `watchCommits`, `listSchemas`, `defineSchemas`, `applySchemaRequest` | The handlers, to bind one by hand |
-| `scopeOf(req, extra?)`, `accessScopeOf(req, access, extra?)`, `handlerScopeOf`, `assertGranted`, `assertWrites`, `writableIn`, `assertExecutionGranted`, `assertExecutionWrites`, `actorOf(req)`, `concealed(run)`, `clampSeconds` | Scope and security helpers |
+| `makeRequestScope(req)` — `.scopeOf(extra?)`, `.accessScopeOf(access, extra?)`, `.actorOf()`; `planningHandlerOf(ctx).handlerScopeOf`; `makePlanningAccessModel(access)` — `.assertGranted`, `.assertWrites`, `.writableIn`; `executionHelper` — `.assertExecutionGranted`, `.assertExecutionWrites`; `guardHelper` — `.concealed(run)`, `.clampSeconds` | Scope and security helpers |
 | `makeDefinitions(runtime, facade)`, `makeSchemaViews(opts)`, `projectCriteriaOf(projects, through?)` | Data-defined schemas and the project narrowing |
-| `makeProjectionProcessor(ctx, opts?)`, `planningQueueHooks(ctx, opts?)` | A generic projection job body and its `onJobDead` |
+| `makeProjectionProcessor(ctx, opts?)`, `makePlanningQueueHooks(ctx, opts?)` | A generic projection job body and its `onJobDead` |
 | `./queue`: `declarePlanningQueue(cfg, opts?)`, `PLANNING_PROJECTION_QUEUE` (`planning-projection`), `PLANNING_PROJECT_JOB` (`planning:project`), `ProjectionRequest` | The projection queue's shared address; each process chooses separately whether to listen |
-| `./store`: `makeMemoryPlanningStore`, `foldPending`, `failPending`, `revisionsFromLog`, `commitEventOf`, `makeCommitHub`, `makeCompositeStore`, `wantsSpecifications` | What stores are built from |
+| `./store`: `makeMemoryPlanningStore`, `foldHelper` (`.foldPending`, `.failPending`, `.revisionsFromLog`, `.commitEventOf`), `makeCommitHub`, `makeCompositeStore`, `wantsSpecifications` | What stores are built from |
 | `./conformance`: `planningConformance`, `conformanceCasesFor`, `planningConformancePlugin`, `conformanceClock`, `ConformanceFailure` | The store conformance suite, runner-agnostic |
 
 ## Wiring
@@ -69,7 +69,7 @@ context.registerEntrypoints(servePlanningEntrypoints(planningProtocols, {
   / `appendPostgresPlanning` install (typed `WithPlanningService`); a context that registered
   `makePlanningService()` / `makePostgresPlanningService()` as a plain service — a generated target's
   `services/planning.ts` — has no `ctx.planning` at all. In a request handler use
-  `planningFor(ctx, req)`: the entity comes from `requireEntityKey(req)`, never the token.
+  `planningHandlerOf(ctx).planningFor(req)`: the entity comes from `makeEntityScope(req).requireEntityKey()`, never the token.
 
 ## Creating and reading a card
 
@@ -131,7 +131,7 @@ wrong form as written.
 Nothing is appended before step 11 — every refusal leaves the log untouched.
 
 1. **Normalize** — deep copy, trimmed text, `parents ∋ parent` (first); a create's draft without
-   `createdBy` gets `creatorOf(scope)` (below).
+   `createdBy` gets `creatorHelper.creatorOf(scope)` (below).
 2. **Scope** — `entityId` must be present.
 3. **Idempotency** — a `key` already in the entity's log answers ITS receipt, before any
    validation or middleware.
@@ -145,14 +145,14 @@ Nothing is appended before step 11 — every refusal leaves the log untouched.
    (`UnknownWorkcardType('retired:…')`). Without the port `Resolved.schemas` IS the code registry.
 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:*`, `createdBy` among them — `assertCreatorFixed`), merged `fields` (`FieldsInvalid`), labels (`LabelNotAllowed`), a moved
+   (`planning:immutable:*`, `createdBy` among them — `creatorHelper.assertCreatorFixed`), 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.
+7. **Card id** — `store.newId?.() ?? options.ids?.() ?? idHelper.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
+9. **Changes** — `changesHelper.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.
@@ -163,14 +163,14 @@ Nothing is appended before step 11 — every refusal leaves the log untouched.
 `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`.
 
-A create's `createdBy` is the scope's subject too — `creatorOf(scope)`: `profileId`, else `userId`,
+A create's `createdBy` is the scope's subject too — `creatorHelper.creatorOf(scope)`: `profileId`, else `userId`,
 else the same two of `scope.actor`. The executor stamps it on every path, so an in-process facade
 create and the HTTP `execute` produce the same owner. An in-process draft that names `createdBy`
 keeps it (explicit wins — a manager creating on someone's behalf); a scope naming nobody (a service
 or system scope) leaves it unset; the wire drops a draft's `createdBy` before the stamp.
 
 `createdBy` never moves after the create (the rule is `planning` → The record model). The executor
-enforces it itself with `assertCreatorFixed` at step 6, after the `before` chain, so a wire body, an
+enforces it itself with `creatorHelper.assertCreatorFixed` at step 6, after the `before` chain, so a wire body, an
 in-process caller and a plugin are refused alike, whatever `@owlmeans/planning` build the host
 resolves. The conformance suite checks a store folds a stored row naming it as the pure fold does.
 
@@ -230,8 +230,8 @@ the store; `bind` replaces the listener, so a store has exactly one.
   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,
+- The projection body is `foldHelper.foldPending(store, cardId, entityId, { onCommitted, publish, touch, limit })`:
+  it applies pending transitions with `applyHelper.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
@@ -239,14 +239,14 @@ the store; `bind` replaces the listener, so a store has exactly one.
   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
+  leaving the rest pending for a retry. `foldHelper.revisionsFromLog` replays past failed transitions the same
   way.
 - A transactional store passes `FoldOptions.unit` — it wraps each transition's writes (a
   savepoint), so a write the database refuses is undone whole and the fold marks that transition
-  failed and goes past it. `foldPending` folds PAST a failure it produces; a row that is ALREADY
+  failed and goes past it. `foldHelper.foldPending` folds PAST a failure it produces; a row that is ALREADY
   failed at the cursor, or a gap in the seqs, is the store's to step over before calling it
   (`planning-postgres` does it in a prelude).
-- `failPending` is what a dead projection job must do, or waiters hang to their timeout.
+- `foldHelper.failPending` is what a dead projection job must do, or waiters hang to their timeout.
 - The data-defined schema port (`schemas`) is optional; `makeCompositeStore` passes the default
   store's through. A store that has it must purge a project's layer with the project.
 - **Run the conformance suite.** `@owlmeans/server-planning/conformance` exports
@@ -257,8 +257,8 @@ the store; `bind` replaces the listener, so a store has exactly one.
   boot serves them all.
 - `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
+- `foldHelper.revisionsFromLog(transitions, limit?)` answers `specs.revisions`.
+- `makeProjectionProcessor(ctx)` + `makePlanningQueueHooks(ctx)` are the store-agnostic job body and
   `onJobDead`; a store with an admission CAS wraps its own around them.
 
 ## A foreign provider
@@ -279,19 +279,19 @@ mapping external records (`mappers`) belongs to that plugin's own store adapter.
 
 ## Scope and security
 
-- Without `opts.access`: `entityId` is `requireEntityKey(req)`; `opts.scope(req, ctx)` adds a
+- Without `opts.access`: `entityId` is `makeEntityScope(req).requireEntityKey()`; `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 (`wireExecution` drops a draft's claim, `withCreator` stamps the
-  subject, `assertCreatorFixed` refuses a body naming `createdBy` — an update never re-owns a card).
-- The organization of a scope is the one the request ACTS IN. `requireEntityKey(req)` answers
+  from the request, never the body (`executionHelper.wireExecution` drops a draft's claim, `creatorHelper.withCreator` stamps the
+  subject, `creatorHelper.assertCreatorFixed` refuses a body naming `createdBy` — an update never re-owns a card).
+- The organization of a scope is the one the request ACTS IN. `makeEntityScope(req).requireEntityKey()` answers
   `req.entity.id`, the stable record id (the token's `entitySlug` only where no entity resolver is
   registered). Behind an OIDC relying party (`@owlmeans/server-oidc-rp`) the acting organization is
   session state: the guard attaches `req.entity` with `id` = the organization claim's frozen
   `entityKey`, so the tenant key survives a rename and follows a switch. Take it in the handler and
   pass it down; never read it from the context or from a 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
+  absent id — on reads and writes alike (`guardHelper.concealed`).
+- Queries arrive in their wire form and are decoded with `wireHelper.decode*Query` before `queryHelper.criteriaOf`, which
   always adds the scope's `entityId`.
 
 ### The access resolver
@@ -349,7 +349,7 @@ target).
 ## Data-defined types and flows
 
 Where the default store has the schema port, `runtime.schemasFor(entityId, project?)` answers the
-resolved layer (`resolveScopedBundle` over the code bundle and the organization's and project's
+resolved layer (`scopedSchemaHelper.resolveScopedBundle` over the code bundle and the organization's and project's
 records), cached per (organization, project) and keyed by the store's `revision()` and the plugin
 registry's version — a write anywhere moves the revision the next lookup reads, so a cached layer is
 never stale; a store's `watch` evicts early. Without the port it answers the code registry itself.

package/build/actions/apply-schema-request.d.ts

@@ -0,0 +1,8 @@
+import { type PlanningDefinitions, type SchemaDefineReply, type SchemaDefineRequest } from '@owlmeans/planning';
+/**
+ * Apply one `schema.define` request to a facade's definitions: the declarations in the request's
+ * mode (flows before types), then the retirements — answering what was written and the layer as it
+ * resolves afterwards.
+ */
+export declare const applySchemaRequest: (definitions: PlanningDefinitions, request: SchemaDefineRequest) => Promise<SchemaDefineReply>;
+//# sourceMappingURL=apply-schema-request.d.ts.map

package/build/actions/apply-schema-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-schema-request.d.ts","sourceRoot":"","sources":["../../src/actions/apply-schema-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,KAAK,mBAAmB,EAA2B,MAAM,oBAAoB,CAAA;AAEzJ;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,gBAChB,mBAAmB,WAAW,mBAAmB,KAC7D,OAAO,CAAC,iBAAiB,CAyB3B,CAAA"}

package/build/actions/apply-schema-request.js

@@ -0,0 +1,31 @@
+import { SchemaWriteMode } from '@owlmeans/planning';
+/**
+ * Apply one `schema.define` request to a facade's definitions: the declarations in the request's
+ * mode (flows before types), then the retirements — answering what was written and the layer as it
+ * resolves afterwards.
+ */
+export const applySchemaRequest = async (definitions, request) => {
+    const layer = request.project != null ? { project: request.project } : {};
+    const declarations = { types: request.types ?? [], flows: request.flows ?? [] };
+    const records = [];
+    switch (request.mode ?? SchemaWriteMode.Define) {
+        case SchemaWriteMode.Put:
+            for (const flow of declarations.flows) {
+                records.push(await definitions.putFlow(flow, layer));
+            }
+            for (const type of declarations.types) {
+                records.push(await definitions.putType(type, layer));
+            }
+            break;
+        case SchemaWriteMode.Seed:
+            records.push(...await definitions.seed(declarations, layer));
+            break;
+        default:
+            records.push(...await definitions.define(declarations, layer));
+    }
+    for (const key of request.retire ?? []) {
+        records.push(await definitions.retire(key.kind, key.key, layer));
+    }
+    return { records, bundle: await definitions.bundle(request.project) };
+};
+//# sourceMappingURL=apply-schema-request.js.map

package/build/actions/apply-schema-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-schema-request.js","sourceRoot":"","sources":["../../src/actions/apply-schema-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAuG,MAAM,oBAAoB,CAAA;AAEzJ;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,EACrC,WAAgC,EAAE,OAA4B,EAClC,EAAE;IAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IACzE,MAAM,YAAY,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE,EAAE,CAAA;IAC/E,MAAM,OAAO,GAAyB,EAAE,CAAA;IAExC,QAAQ,OAAO,CAAC,IAAI,IAAI,eAAe,CAAC,MAAM,EAAE,CAAC;QAC/C,KAAK,eAAe,CAAC,GAAG;YACtB,KAAK,MAAM,IAAI,IAAI,YAAY,CAAC,KAAK,EAAE,CAAC;gBACtC,OAAO,CAAC,IAAI,CAAC,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;YACtD,CAAC;YACD,KAAK,MAAM,IAAI,IAAI,YAAY,CAAC,KAAK,EAAE,CAAC;gBACtC,OAAO,CAAC,IAAI,CAAC,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;YACtD,CAAC;YACD,MAAK;QACP,KAAK,eAAe,CAAC,IAAI;YACvB,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC,CAAA;YAC5D,MAAK;QACP;YACE,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,WAAW,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC,CAAA;IAClE,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC;QACvC,OAAO,CAAC,IAAI,CAAC,MAAM,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;IAClE,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAA;AACvE,CAAC,CAAA"}

package/build/actions/commit.d.ts

@@ -1,6 +1,6 @@
-import { handlers } from '@owlmeans/server-api';
 import type { PlanningProtocols } from '@owlmeans/planning';
-import type { Context, PlanningHandlerOptions } from '../types.js';
+import type { PlanningHandlerOptions } from '../types.js';
+import type { RequestHandler } from './types.js';
 /**
  * The poll tool: a commit's status, held open up to `wait` seconds (clamped to `maxPoll`).
  *
@@ -10,5 +10,5 @@ import type { Context, PlanningHandlerOptions } from '../types.js';
  *
  * @throws {WorkcardNotFound} for another entity's transition
  */
-export declare const getCommit: (protocol: PlanningProtocols['commit']['get'], opts?: PlanningHandlerOptions) => ReturnType<ReturnType<typeof handlers<Context>>['request']>;
+export declare const getCommit: (protocol: PlanningProtocols['commit']['get'], opts?: PlanningHandlerOptions) => RequestHandler;
 //# sourceMappingURL=commit.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/actions/commit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAAW,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,aACV,iBAAiB,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,SAAS,sBAAsB,KAC1E,cAqCE,CAAA"}

package/build/actions/commit.js

@@ -1,6 +1,7 @@
 import { handlers } from '@owlmeans/server-api';
 import { CommitState, MAX_COMMIT_POLL } from '@owlmeans/planning';
-import { clampSeconds, concealed, handlerFacade } from '../utils/index.js';
+import { guardHelper } from '../utils/guard.js';
+import { planningHandlerOf } from '../utils/handler.js';
 /**
  * The poll tool: a commit's status, held open up to `wait` seconds (clamped to `maxPoll`).
  *
@@ -10,11 +11,11 @@ import { clampSeconds, concealed, handlerFacade } from '../utils/index.js';
  *
  * @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);
+export const getCommit = (protocol, opts) => handlers().request(protocol, async (req, ctx) => guardHelper.concealed(async () => {
+    const facade = await planningHandlerOf(ctx).handlerFacade(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);
+    const wait = guardHelper.clampSeconds(req.query?.wait, opts?.maxPoll ?? MAX_COMMIT_POLL);
     if (status.state !== CommitState.Pending || wait <= 0) {
         return status;
     }

package/build/actions/commit.js.map

@@ -1 +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"}
+{"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,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,QAA4C,EAAE,IAA6B,EAC3D,EAAE,CAClB,QAAQ,EAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,IAA2B,EAAE;IAChH,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;IACpE,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,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,IAAI,eAAe,CAAC,CAAA;IACxF,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/define-schemas.d.ts

@@ -0,0 +1,13 @@
+import { type PlanningProtocols } from '@owlmeans/planning';
+import type { PlanningHandlerOptions } from '../types.js';
+import type { RequestHandler } from './types.js';
+/**
+ * The write of data-defined types and flows. A project layer needs the project in the access's
+ * `writes` when the resolver answers it; then `grants.defineSchemas` gates when the resolver answers
+ * grants (the organization-wide layer needs `true`, a project layer its id).
+ *
+ * @throws {PlanningUnsupported} where the store holds no data-defined schemas
+ * @throws {PlanningForbidden | SchemaConflict | SchemaSealed | SchemaInvalid | SchemaInUse | WorkcardNotFound}
+ */
+export declare const defineSchemas: (protocol: NonNullable<PlanningProtocols['schema']['define']>, opts?: PlanningHandlerOptions) => RequestHandler;
+//# sourceMappingURL=define-schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"define-schemas.d.ts","sourceRoot":"","sources":["../../src/actions/define-schemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,KAAK,iBAAiB,EAAoD,MAAM,oBAAoB,CAAA;AAClI,OAAO,KAAK,EAAW,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAKlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,aACd,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,SAAS,sBAAsB,KAC1F,cAcE,CAAA"}

package/build/actions/define-schemas.js

@@ -0,0 +1,28 @@
+import { handlers } from '@owlmeans/server-api';
+import { PlanningUnsupported } from '@owlmeans/planning';
+import { makePlanningAccessModel } from '../utils/access.js';
+import { guardHelper } from '../utils/guard.js';
+import { planningHandlerOf } from '../utils/handler.js';
+import { applySchemaRequest } from './apply-schema-request.js';
+/**
+ * The write of data-defined types and flows. A project layer needs the project in the access's
+ * `writes` when the resolver answers it; then `grants.defineSchemas` gates when the resolver answers
+ * grants (the organization-wide layer needs `true`, a project layer its id).
+ *
+ * @throws {PlanningUnsupported} where the store holds no data-defined schemas
+ * @throws {PlanningForbidden | SchemaConflict | SchemaSealed | SchemaInvalid | SchemaInUse | WorkcardNotFound}
+ */
+export const defineSchemas = (protocol, opts) => handlers().request(protocol, async (req, ctx) => guardHelper.concealed(async () => {
+    const { facade, access } = await planningHandlerOf(ctx).handlerScopeOf(req, opts);
+    const request = (req.body ?? {});
+    if (facade.definitions == null) {
+        throw new PlanningUnsupported('definitions');
+    }
+    const model = makePlanningAccessModel(access);
+    if (request.project != null) {
+        model.assertWrites(request.project);
+    }
+    model.assertGranted('defineSchemas', request.project);
+    return await applySchemaRequest(facade.definitions, request);
+}));
+//# sourceMappingURL=define-schemas.js.map

package/build/actions/define-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-schemas.js","sourceRoot":"","sources":["../../src/actions/define-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAA4E,MAAM,oBAAoB,CAAA;AAElI,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAG9D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,QAA4D,EAAE,IAA6B,EAC3E,EAAE,CAClB,QAAQ,EAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,IAAgC,EAAE;IACrH,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,iBAAiB,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;IACjF,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAwB,CAAA;IACvD,IAAI,MAAM,CAAC,WAAW,IAAI,IAAI,EAAE,CAAC;QAC/B,MAAM,IAAI,mBAAmB,CAAC,aAAa,CAAC,CAAA;IAC9C,CAAC;IACD,MAAM,KAAK,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAA;IAC7C,IAAI,OAAO,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;QAC5B,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IACrC,CAAC;IACD,KAAK,CAAC,aAAa,CAAC,eAAe,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IAErD,OAAO,MAAM,kBAAkB,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;AAC9D,CAAC,CAAC,CAAC,CAAA"}

package/build/actions/execute.d.ts

@@ -1,34 +1,14 @@
-import { handlers } from '@owlmeans/server-api';
 import type { ExecuteOptions, ExecuteRequest, PlanningFacade, PlanningProtocols, PlanningScope, TransitionExecution } from '@owlmeans/planning';
-import type { Context, PlanningAccess, PlanningHandlerOptions } from '../types.js';
-/**
- * What a wire execution may say. `actor` is dropped — the scope names the writer — and a create's
- * `createdBy` claim is dropped too: the executor's {@link withCreator} stamps the authenticated
- * subject, the same rule an in-process create follows. Applied here as well, so the returned
- * execution already carries it. A `createdBy` in `changes` or `unset` is not dropped: the executor
- * refuses it on every action (`assertCreatorFixed`), so no body moves an owner.
- */
+import type { PlanningAccess, PlanningHandlerOptions } from '../types.js';
+import type { RequestHandler } from './types.js';
+/** The one write route. */
+export declare const executePlanning: (protocol: PlanningProtocols['execute'], opts?: PlanningHandlerOptions) => RequestHandler;
+/** @deprecated compat:factory-refactor — use `executionHelper.wireExecution(…)` */
 export declare const wireExecution: (body: ExecuteRequest, scope: PlanningScope) => TransitionExecution;
-/** `wait`/`timeout` as a server grants them: the timeout never holds a request past `maxPoll`. */
+/** @deprecated compat:factory-refactor — use `executionHelper.executeOptionsOf(…)` */
 export declare const executeOptionsOf: (body: Pick<ExecuteRequest, 'wait' | 'timeout'>, maxPoll: number) => ExecuteOptions;
-/**
- * Refuse an execution outside the access's `writes`: the card it acts on (a specification through
- * its parent card), or every parent a create names, must be one {@link writableIn} admits. A create
- * of a project is `grants.createProjects`' alone. A card or parent this scope cannot see is left to
- * the executor, which answers it as absent.
- *
- * @throws {PlanningForbidden}
- */
+/** @deprecated compat:factory-refactor — use `executionHelper.assertExecutionWrites(…)` */
 export declare const assertExecutionWrites: (facade: PlanningFacade, exec: TransitionExecution, access?: PlanningAccess) => Promise<void>;
-/**
- * The access a wire execution needs. `writes` first ({@link assertExecutionWrites}); then the
- * grants: `createProjects` for a project create (its primary parent, or the root),
- * `deleteProjects` for the delete of a project card. A card this scope cannot see is left to the
- * executor, which answers it as absent.
- *
- * @throws {PlanningForbidden}
- */
+/** @deprecated compat:factory-refactor — use `executionHelper.assertExecutionGranted(…)` */
 export declare const assertExecutionGranted: (facade: PlanningFacade, exec: TransitionExecution, access?: PlanningAccess) => Promise<void>;
-/** 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

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/actions/execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAK/C,OAAO,KAAK,EACV,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAEtG,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGlF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,SAAU,cAAc,SAAS,aAAa,KAAG,mBAO1E,CAAA;AAED,kGAAkG;AAClG,eAAO,MAAM,gBAAgB,SAAU,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC,WAAW,MAAM,KAAG,cAOlG,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,WACxB,cAAc,QAAQ,mBAAmB,WAAW,cAAc,KACzE,OAAO,CAAC,IAAI,CAqCd,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,WACzB,cAAc,QAAQ,mBAAmB,WAAW,cAAc,KACzE,OAAO,CAAC,IAAI,CAed,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"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/actions/execute.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAEtG,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAW,cAAc,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAIlF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,2BAA2B;AAC3B,eAAO,MAAM,eAAe,aAChB,iBAAiB,CAAC,SAAS,CAAC,SAAS,sBAAsB,KACpE,cAWE,CAAA;AAEL,mFAAmF;AACnF,eAAO,MAAM,aAAa,SAAU,cAAc,SAAS,aAAa,KAAG,mBAC/B,CAAA;AAE5C,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,SAAU,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC,WAAW,MAAM,KAAG,cAClD,CAAA;AAEjD,2FAA2F;AAC3F,eAAO,MAAM,qBAAqB,WACxB,cAAc,QAAQ,mBAAmB,WAAW,cAAc,KACzE,OAAO,CAAC,IAAI,CAAsE,CAAA;AAErF,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB,WACzB,cAAc,QAAQ,mBAAmB,WAAW,cAAc,KACzE,OAAO,CAAC,IAAI,CAAuE,CAAA"}

package/build/actions/execute.js

@@ -1,109 +1,25 @@
 import { handlers } from '@owlmeans/server-api';
-import { DEFAULT_COMMIT_TIMEOUT, isProject, isSpecification, MAX_COMMIT_POLL, normalizeParents, PlanningForbidden, TransitionAction, WorkcardKind, } from '@owlmeans/planning';
-import { withCreator } from '../executor/creator.js';
-import { assertGranted, concealed, handlerScopeOf, writableIn } from '../utils/index.js';
-/**
- * What a wire execution may say. `actor` is dropped — the scope names the writer — and a create's
- * `createdBy` claim is dropped too: the executor's {@link withCreator} stamps the authenticated
- * subject, the same rule an in-process create follows. Applied here as well, so the returned
- * execution already carries it. A `createdBy` in `changes` or `unset` is not dropped: the executor
- * refuses it on every action (`assertCreatorFixed`), so no body moves an owner.
- */
-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;
-        exec.card = draft;
-    }
-    return withCreator(exec, scope);
-};
-/** `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) };
-};
-/**
- * Refuse an execution outside the access's `writes`: the card it acts on (a specification through
- * its parent card), or every parent a create names, must be one {@link writableIn} admits. A create
- * of a project is `grants.createProjects`' alone. A card or parent this scope cannot see is left to
- * the executor, which answers it as absent.
- *
- * @throws {PlanningForbidden}
- */
-export const assertExecutionWrites = async (facade, exec, access) => {
-    if (access?.writes == null) {
-        return;
-    }
-    const admitted = async (card) => {
-        if (writableIn(access, card)) {
-            return true;
-        }
-        if (!isSpecification(card) || card.parent == null) {
-            return false;
-        }
-        const parent = await facade.cards.load(card.parent);
-        return parent == null || writableIn(access, parent);
-    };
-    if (exec.action === TransitionAction.Create && exec.card != null && typeof exec.card === 'object') {
-        if (exec.card.kind === WorkcardKind.Project) {
-            return;
-        }
-        const parents = normalizeParents(exec.card.parent, exec.card.parents);
-        if (parents.length === 0) {
-            throw new PlanningForbidden('writes:root');
-        }
-        for (const id of parents) {
-            const parent = await facade.cards.load(id);
-            if (parent != null && !await admitted(parent)) {
-                throw new PlanningForbidden(`writes:${id}`);
-            }
-        }
-        return;
-    }
-    if (typeof exec.card === 'string' && exec.card !== '') {
-        const card = await facade.cards.load(exec.card);
-        if (card != null && !await admitted(card)) {
-            throw new PlanningForbidden(`writes:${exec.card}`);
-        }
-    }
-};
-/**
- * The access a wire execution needs. `writes` first ({@link assertExecutionWrites}); then the
- * grants: `createProjects` for a project create (its primary parent, or the root),
- * `deleteProjects` for the delete of a project card. A card this scope cannot see is left to the
- * executor, which answers it as absent.
- *
- * @throws {PlanningForbidden}
- */
-export const assertExecutionGranted = async (facade, exec, access) => {
-    await assertExecutionWrites(facade, exec, access);
-    if (access?.grants == null) {
-        return;
-    }
-    if (exec.action === TransitionAction.Create && typeof exec.card === 'object' && exec.card?.kind === WorkcardKind.Project) {
-        assertGranted(access, 'createProjects', normalizeParents(exec.card.parent, exec.card.parents)[0]);
-        return;
-    }
-    if (exec.action === TransitionAction.Delete && typeof exec.card === 'string') {
-        const card = await facade.cards.load(exec.card);
-        if (card != null && isProject(card)) {
-            assertGranted(access, 'deleteProjects', card.id);
-        }
-    }
-};
+import { MAX_COMMIT_POLL } from '@owlmeans/planning';
+import { guardHelper } from '../utils/guard.js';
+import { planningHandlerOf } from '../utils/handler.js';
+import { executionHelper } from './execution.js';
 /** The one write route. */
-export const executePlanning = (protocol, opts) => handlers().request(protocol, async (req, ctx) => concealed(async () => {
-    const { facade, access } = await handlerScopeOf(ctx, req, opts);
+export const executePlanning = (protocol, opts) => handlers().request(protocol, async (req, ctx) => guardHelper.concealed(async () => {
+    const { facade, access } = await planningHandlerOf(ctx).handlerScopeOf(req, opts);
     const body = (req.body ?? {});
-    const exec = wireExecution(body, facade.scope);
-    await assertExecutionGranted(facade, exec, access);
-    const receipt = await facade.execute(exec, executeOptionsOf(body, opts?.maxPoll ?? MAX_COMMIT_POLL));
+    const exec = executionHelper.wireExecution(body, facade.scope);
+    await executionHelper.assertExecutionGranted(facade, exec, access);
+    const receipt = await facade.execute(exec, executionHelper.executeOptionsOf(body, opts?.maxPoll ?? MAX_COMMIT_POLL));
     return receipt.card !== undefined
         ? { transition: receipt.transition, card: receipt.card }
         : { transition: receipt.transition };
 }));
+/** @deprecated compat:factory-refactor — use `executionHelper.wireExecution(…)` */
+export const wireExecution = (body, scope) => executionHelper.wireExecution(body, scope);
+/** @deprecated compat:factory-refactor — use `executionHelper.executeOptionsOf(…)` */
+export const executeOptionsOf = (body, maxPoll) => executionHelper.executeOptionsOf(body, maxPoll);
+/** @deprecated compat:factory-refactor — use `executionHelper.assertExecutionWrites(…)` */
+export const assertExecutionWrites = async (facade, exec, access) => await executionHelper.assertExecutionWrites(facade, exec, access);
+/** @deprecated compat:factory-refactor — use `executionHelper.assertExecutionGranted(…)` */
+export const assertExecutionGranted = async (facade, exec, access) => await executionHelper.assertExecutionGranted(facade, exec, access);
 //# sourceMappingURL=execute.js.map