@owlmeans/client-planning 0.1.18-rc.2 → 0.1.18-rc.21

package/src/consts.ts

@@ -1,24 +1,3 @@
-import type { Relationship, Workcard } from '@owlmeans/planning'
-import { stateAlias } from '@owlmeans/state'
-import type { StateAlias } from '@owlmeans/state'
-import type { PlanningCommitRecord, PlanningStoreAliases } from './types.js'
-
-/**
- * The ONE card store. Projects, cards and specifications share an id space on the server, so they
- * share it here too — a store per kind would let a list reload of one kind drop another's rows.
- */
-export const CARDS: StateAlias<Workcard> = stateAlias<Workcard>('planning-card-state')
-
-export const LINKS: StateAlias<Relationship> = stateAlias<Relationship>('planning-link-state')
-
-/** What the client has learned about each transition it wrote or saw, keyed by transition id. */
-export const COMMITS: StateAlias<PlanningCommitRecord> = stateAlias<PlanningCommitRecord>('planning-commit-state')
-
-export const DEFAULT_STORE_ALIASES: Readonly<PlanningStoreAliases> = Object.freeze({
-  cards: CARDS,
-  links: LINKS,
-  commits: COMMITS,
-})
 
 /**
  * How much longer than its own `wait` a long poll's HTTP deadline is, in milliseconds — a held

package/src/definitions.ts

@@ -0,0 +1,88 @@
+import type { BasicConfig, BasicContext } from '@owlmeans/context'
+import { PlanningUnsupported, SchemaWriteMode, scopedRegistryOf } from '@owlmeans/planning'
+import type {
+  PlanningProtocols, SchemaDefineReply, SchemaDefineRequest, ScopedSchemaRegistry,
+} from '@owlmeans/planning'
+import type { RemoteDefinitions, RemoteDefinitionsOptions } from './types.js'
+
+const clean = <T extends object>(record: T): T =>
+  Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)) as T
+
+/**
+ * Data-defined types and flows over a tree declared with `definitions: true`: a layer's registry is
+ * read through `schema.list` (with its `project`) and cached per project; every write goes through
+ * `schema.define` and drops the whole cache — an organization-wide write reaches every project's
+ * layer. The records of a layer are the server's alone (`records` refuses).
+ *
+ * @throws {PlanningUnsupported} for a tree declared without `definitions`
+ */
+export const makeRemoteDefinitions = <C extends BasicConfig, T extends BasicContext<C>>(
+  context: T, protocols: PlanningProtocols, opts: RemoteDefinitionsOptions = {}
+): RemoteDefinitions => {
+  const define = protocols.schema.define
+  if (define == null) {
+    throw new PlanningUnsupported('client:definitions')
+  }
+  const cache = new Map<string, Promise<ScopedSchemaRegistry>>()
+
+  const invalidate = (): void => {
+    cache.clear()
+    opts.onWrite?.()
+  }
+
+  const registry = (project?: string): Promise<ScopedSchemaRegistry> => {
+    const key = project ?? ''
+    let entry = cache.get(key)
+    if (entry == null) {
+      const loading = (async () => scopedRegistryOf(await context.entrypoint(protocols.schema.list).call({
+        query: project != null ? { project } : {}, timeout: opts.timeout,
+      })))()
+      entry = loading
+      cache.set(key, loading)
+      // A failed read is forgotten, so the next caller asks again instead of inheriting the error.
+      loading.catch(() => {
+        if (cache.get(key) === loading) {
+          cache.delete(key)
+        }
+      })
+    }
+    return entry
+  }
+
+  const write = async (request: SchemaDefineRequest): Promise<SchemaDefineReply> => {
+    try {
+      return await context.entrypoint(define).call({ body: clean(request), timeout: opts.timeout })
+    } finally {
+      invalidate()
+    }
+  }
+
+  return {
+    bundle: async project => (await registry(project)).bundle(),
+
+    registry,
+
+    records: async () => {
+      throw new PlanningUnsupported('client:definitions:records')
+    },
+
+    putType: async (type, layer) =>
+      (await write({ project: layer?.project, mode: SchemaWriteMode.Put, types: [type] })).records[0],
+
+    putFlow: async (flow, layer) =>
+      (await write({ project: layer?.project, mode: SchemaWriteMode.Put, flows: [flow] })).records[0],
+
+    define: async (declarations, layer) =>
+      (await write({ project: layer?.project, mode: SchemaWriteMode.Define, ...declarations })).records,
+
+    seed: async (declarations, layer) =>
+      (await write({ project: layer?.project, mode: SchemaWriteMode.Seed, ...declarations })).records,
+
+    retire: async (kind, key, layer) => {
+      const { records } = await write({ project: layer?.project, retire: [{ kind, key }] })
+      return records[records.length - 1]
+    },
+
+    invalidate,
+  }
+}

package/src/events.ts

@@ -1,8 +1,7 @@
-import { CommitState, TransitionAction, WorkcardKind } from '@owlmeans/planning'
-import type { CommitEvent, PlanningFacade, TransitionReceiptView, Workcard } from '@owlmeans/planning'
+import { CommitState, TransitionAction, WorkcardKind, type CommitEvent, type PlanningFacade, type TransitionReceiptView, type Workcard } from '@owlmeans/planning'
 import { syncLinks } from './stores.js'
 import type { PlanningStores } from './types.js'
-import { dropCard, putCard, putCommit } from './utils/record.js'
+import { recordHelper } from './utils/record.js'
 
 /**
  * Fold one commit frame into the mirror.
@@ -22,7 +21,7 @@ export const applyCommitEvent = async (
 ): Promise<void> => {
   const known = await stores.cards.load(event.card)
 
-  await putCommit(stores.commits, {
+  await recordHelper.putCommit(stores.commits, {
     id: event.transition,
     card: event.card,
     entityId: event.entityId,
@@ -50,7 +49,7 @@ export const applyCommitEvent = async (
   }
 
   if (event.action === TransitionAction.Delete) {
-    await dropCard(stores, event.card, event.kind === WorkcardKind.Project)
+    await recordHelper.dropCard(stores, event.card, event.kind === WorkcardKind.Project)
     return
   }
 
@@ -60,9 +59,9 @@ export const applyCommitEvent = async (
 
   if (record === null) {
     // Committed, and gone by the time it was read: a later delete won the race.
-    await dropCard(stores, event.card, event.kind === WorkcardKind.Project)
+    await recordHelper.dropCard(stores, event.card, event.kind === WorkcardKind.Project)
   } else if (record !== undefined) {
-    await putCard(stores.cards, record)
+    await recordHelper.putCard(stores.cards, record)
   }
 
   if (facade != null && (event.action === TransitionAction.Link || event.action === TransitionAction.Unlink)) {
@@ -81,7 +80,7 @@ export const applyCommitEvent = async (
 export const applyReceipt = async (stores: PlanningStores, receipt: TransitionReceiptView): Promise<void> => {
   const { transition } = receipt
   if (transition.id != null) {
-    await putCommit(stores.commits, {
+    await recordHelper.putCommit(stores.commits, {
       id: transition.id,
       card: transition.card,
       entityId: transition.entityId,
@@ -99,11 +98,11 @@ export const applyReceipt = async (stores: PlanningStores, receipt: TransitionRe
     return
   }
   if (transition.commit.state === CommitState.Committed && transition.action === TransitionAction.Delete) {
-    await dropCard(stores, transition.card, transition.kind === WorkcardKind.Project)
+    await recordHelper.dropCard(stores, transition.card, transition.kind === WorkcardKind.Project)
     return
   }
   if (receipt.card != null) {
-    await putCard(stores.cards, receipt.card)
+    await recordHelper.putCard(stores.cards, receipt.card)
     return
   }
 
@@ -116,6 +115,6 @@ export const applyReceipt = async (stores: PlanningStores, receipt: TransitionRe
 /** Write cards the caller read on its own, under the same newer-fold-wins rule as a commit. */
 export const applyCards = async (stores: Pick<PlanningStores, 'cards'>, cards: Workcard[]): Promise<void> => {
   for (const card of cards) {
-    await putCard(stores.cards, card)
+    await recordHelper.putCard(stores.cards, card)
   }
 }

package/src/facade.ts

@@ -1,6 +1,6 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
 import {
-  CommitFailed, CommitState, DEFAULT_COMMIT_TIMEOUT, PlanningError, PlanningUnsupported, WorkcardNotFound,
+  CommitFailed, CommitState, DEFAULT_COMMIT_TIMEOUT, PlanningError, PlanningUnsupported, WorkcardKind, WorkcardNotFound,
   encodeRelationshipQuery, encodeSpecificationQuery, encodeSummaryQuery, encodeTransitionQuery,
   encodeWorkcardQuery, modelOf,
 } from '@owlmeans/planning'
@@ -159,11 +159,23 @@ export const makeRemoteFacade = <C extends BasicConfig, T extends BasicContext<C
     model: async <R extends Workcard = Workcard>(card: R | string): Promise<WorkcardModel<R>> => {
       await opts.loadSchemas?.()
       const record = typeof card === 'string' ? await facade.cards.get(card) as R : card
+      // A card of a project resolves its types in that project's layer; the organization's layer
+      // is the service's own bundle, and a specification's type is always code's.
+      const project = opts.definitions == null
+        ? undefined
+        : record.kind === WorkcardKind.Project ? record.id : record.kind === WorkcardKind.Card ? record.parent : undefined
+      if (project == null) {
+        return modelOf<R>(record, facade)
+      }
 
-      return modelOf<R>(record, facade)
+      return modelOf<R>(record, { ...facade, schemas: await opts.definitions!.registry(project) })
     },
   }
 
+  if (opts.definitions != null) {
+    facade.definitions = opts.definitions
+  }
+
   return facade
 }
 

package/src/feed.ts

@@ -1,14 +1,16 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import { criteriaOf, PLANNING_SERVICE } from '@owlmeans/planning'
-import type { Relationship, RelationshipQuery, Unsubscribe } from '@owlmeans/planning'
+import { logger } from '@owlmeans/log'
+import { criteriaOf, PLANNING_SERVICE, type Relationship, type RelationshipQuery, type Unsubscribe } from '@owlmeans/planning'
 import type { Criteria } from '@owlmeans/resource'
 import { applyCards, applyCommitEvent } from './events.js'
 import { planningStoresOf, syncCards, syncLinks } from './stores.js'
 import type { PlanningClientService, PlanningFeed, PlanningFeedOptions, PlanningFeedState } from './types.js'
-import { clean } from './utils/record.js'
+import { recordHelper } from './utils/record.js'
+
+const log = logger('client-planning')
 
 const linkCriteriaOf = (query: RelationshipQuery): Criteria<Relationship> =>
-  clean({ from: query.from, to: query.to, type: query.type }) as Criteria<Relationship>
+  recordHelper.clean({ from: query.from, to: query.to, type: query.type }) as Criteria<Relationship>
 
 /**
  * Keep the state mirror current: subscribe to commits FIRST, then seed from the list, then fold
@@ -95,7 +97,7 @@ export const makePlanningFeed = <C extends BasicConfig, T extends BasicContext<C
         try {
           await applyCommitEvent(stores, event, facade)
         } catch (e) {
-          console.error('Planning feed apply error:', e)
+          log.warn('Planning feed apply failed', { card: event.card, error: e })
         }
       }, opts.filter)
       if (stopped) {

package/src/index.ts

@@ -1,8 +1,10 @@
 export type * from './types.js'
 
 export * from './consts.js'
+export * from './utils.js'
 export * from './client.js'
 export * from './facade.js'
+export * from './definitions.js'
 export * from './commits.js'
 export * from './stores.js'
 export * from './events.js'

package/src/stores.ts

@@ -1,11 +1,10 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
 import type { Relationship, Workcard } from '@owlmeans/planning'
 import type { Criteria } from '@owlmeans/resource'
-import { appendStateResource } from '@owlmeans/state'
-import type { StateResourceAppend } from '@owlmeans/state'
-import { DEFAULT_STORE_ALIASES } from './consts.js'
+import { appendStateResource, type StateResourceAppend } from '@owlmeans/state'
+import { DEFAULT_STORE_ALIASES } from './utils.js'
 import type { PlanningStoreAliases, PlanningStores, SyncOptions, WithPlanningStores } from './types.js'
-import { idsOf, putCard, putLink } from './utils/record.js'
+import { recordHelper } from './utils/record.js'
 
 /**
  * Register the planning state mirror: ONE card store for every kind, a link store and a commit
@@ -53,9 +52,9 @@ export const planningStoresOf = (context: BasicContext<any>): PlanningStores | n
 export const syncCards = async (
   store: PlanningStores['cards'], items: Workcard[], where?: Criteria<Workcard>, opts?: SyncOptions
 ): Promise<void> => {
-  await dropUnnamed(store, idsOf(items), where, opts)
+  await dropUnnamed(store, recordHelper.idsOf(items), where, opts)
   for (const item of items) {
-    await putCard(store, item)
+    await recordHelper.putCard(store, item)
   }
 }
 
@@ -63,9 +62,9 @@ export const syncCards = async (
 export const syncLinks = async (
   store: PlanningStores['links'], items: Relationship[], where?: Criteria<Relationship>, opts?: SyncOptions
 ): Promise<void> => {
-  await dropUnnamed(store, idsOf(items), where, opts)
+  await dropUnnamed(store, recordHelper.idsOf(items), where, opts)
   for (const item of items) {
-    await putLink(store, item)
+    await recordHelper.putLink(store, item)
   }
 }
 
@@ -74,7 +73,7 @@ const dropUnnamed = async <T extends Workcard | Relationship>(
 ): Promise<void> => {
   const keep = new Set([...named, ...(opts?.keep ?? [])])
   const scoped = await (store as PlanningStores['cards']).list(where as Criteria<Workcard>)
-  const stale = idsOf(scoped.items).filter(id => !keep.has(id))
+  const stale = recordHelper.idsOf(scoped.items).filter(id => !keep.has(id))
   if (stale.length > 0) {
     await store.purge({ id: { $in: stale } })
   }

package/src/types.local.ts

@@ -0,0 +1,6 @@
+import type { CommitEvent, CommitFilter } from '@owlmeans/planning'
+
+export interface Subscription {
+  listener: (event: CommitEvent) => void | Promise<void>
+  filter?: CommitFilter
+}

package/src/types.ts

@@ -2,9 +2,9 @@ import type { ClientConfig, ClientContext } from '@owlmeans/client-context'
 import type { LazyService } from '@owlmeans/context'
 import type { AbstractRequest, EntrypointProtocolDeclaration } from '@owlmeans/entrypoint'
 import type {
-  CommitFilter, CommitSource, CommitState, PlanningFacade, PlanningProtocols, PlanningSchemaRegistry,
-  PlanningScope, PlanningService, Relationship, RelationshipQuery, TransitionAction, Workcard,
-  WorkcardKind, WorkcardQuery,
+  CommitFilter, CommitSource, CommitState, PlanningDefinitions, PlanningFacade, PlanningProtocols,
+  PlanningSchemaRegistry, PlanningScope, PlanningService, Relationship, RelationshipQuery, TransitionAction,
+  Workcard, WorkcardKind, WorkcardQuery,
 } from '@owlmeans/planning'
 import type { Criteria, ResourceRecord } from '@owlmeans/resource'
 import type { Connection } from '@owlmeans/socket'
@@ -56,6 +56,21 @@ export interface PlanningClientService extends PlanningService, LazyService {
   loadSchemas: (opts?: { force?: boolean }) => Promise<PlanningSchemaRegistry>
   /** Release the shared commit socket. */
   close: () => Promise<void>
+  /** Data-defined types and flows — present when the tree was declared with `definitions: true`. */
+  definitions?: RemoteDefinitions
+}
+
+/** The client half of `PlanningDefinitions`: layers cached per project, dropped on any write. */
+export interface RemoteDefinitions extends PlanningDefinitions {
+  /** Forget every cached layer — the next read asks the server. */
+  invalidate: () => void
+}
+
+export interface RemoteDefinitionsOptions {
+  /** Milliseconds, for every definitions call. */
+  timeout?: number
+  /** Called after every write (the service reloads its own bundle on the next `model()`). */
+  onWrite?: () => void
 }
 
 export interface WithPlanningClient {
@@ -86,6 +101,8 @@ export interface RemoteFacadeOptions {
   loadSchemas?: () => Promise<PlanningSchemaRegistry>
   timeout?: number
   stores?: () => PlanningStores | null
+  /** The data-defined schema surface, shared by every facade of the service. */
+  definitions?: RemoteDefinitions
 }
 
 /** One row per transition the client wrote or saw settle. */

package/src/utils/record.ts

@@ -18,7 +18,7 @@ const stable = (value: unknown): unknown => {
 }
 
 /** Same content, whatever order the keys arrived in. */
-export const sameRecord = (left: unknown, right: unknown): boolean =>
+const sameRecord = (left: unknown, right: unknown): boolean =>
   JSON.stringify(stable(left)) === JSON.stringify(stable(right))
 
 /**
@@ -28,7 +28,7 @@ export const sameRecord = (left: unknown, right: unknown): boolean =>
  * commit landed must not undo that commit. The head only ever grows: a head this client allocated
  * (`applyReceipt`) stays until a fold catches up with it.
  */
-export const putCard = async (store: StateResource<Workcard>, card: Workcard): Promise<Workcard> => {
+const putCard = async (store: StateResource<Workcard>, card: Workcard): Promise<Workcard> => {
   if (card.id == null) {
     return card
   }
@@ -46,7 +46,7 @@ export const putCard = async (store: StateResource<Workcard>, card: Workcard): P
   return next
 }
 
-export const putLink = async (store: StateResource<Relationship>, link: Relationship): Promise<void> => {
+const putLink = async (store: StateResource<Relationship>, link: Relationship): Promise<void> => {
   if (link.id == null) {
     return
   }
@@ -58,7 +58,7 @@ export const putLink = async (store: StateResource<Relationship>, link: Relation
 }
 
 /** Drop a card, whatever lives under it when it is a project, and every link touching any of them. */
-export const dropCard = async (stores: PlanningStores, id: string, project: boolean): Promise<void> => {
+const dropCard = async (stores: PlanningStores, id: string, project: boolean): Promise<void> => {
   const ids = [id]
   if (project) {
     const children = await stores.cards.list({ parents: { $contains: [id] } })
@@ -71,7 +71,7 @@ export const dropCard = async (stores: PlanningStores, id: string, project: bool
 }
 
 /** Record what is known about a transition, merged over what was known before. */
-export const putCommit = async (
+const putCommit = async (
   store: StateResource<PlanningCommitRecord>, record: Partial<PlanningCommitRecord> & { id: string, state: CommitState }
 ): Promise<PlanningCommitRecord> => {
   const known = await store.load(record.id)
@@ -84,8 +84,12 @@ export const putCommit = async (
   return next
 }
 
-export const clean = <T extends object>(record: T): T =>
+const clean = <T extends object>(record: T): T =>
   Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)) as T
 
-export const idsOf = <T extends ResourceRecord>(records: T[]): string[] =>
+const idsOf = <T extends ResourceRecord>(records: T[]): string[] =>
   records.map(record => record.id).filter((id): id is string => id != null)
+
+export const createRecordHelper = () => ({ sameRecord, putCard, putLink, dropCard, putCommit, clean, idsOf })
+
+export const recordHelper = createRecordHelper()

package/src/utils/types.ts

@@ -0,0 +1,3 @@
+import type { createRecordHelper } from './record.js'
+
+export type RecordHelper = ReturnType<typeof createRecordHelper>

package/src/utils.ts

@@ -0,0 +1,20 @@
+import { type StateAlias, stateAlias } from '@owlmeans/state'
+import type { Relationship, Workcard } from '@owlmeans/planning'
+import type { PlanningCommitRecord, PlanningStoreAliases } from './types.js'
+
+/**
+ * The ONE card store. Projects, cards and specifications share an id space on the server, so they
+ * share it here too — a store per kind would let a list reload of one kind drop another's rows.
+ */
+export const CARDS: StateAlias<Workcard> = stateAlias<Workcard>('planning-card-state')
+
+export const LINKS: StateAlias<Relationship> = stateAlias<Relationship>('planning-link-state')
+
+/** What the client has learned about each transition it wrote or saw, keyed by transition id. */
+export const COMMITS: StateAlias<PlanningCommitRecord> = stateAlias<PlanningCommitRecord>('planning-commit-state')
+
+export const DEFAULT_STORE_ALIASES: Readonly<PlanningStoreAliases> = Object.freeze({
+  cards: CARDS,
+  links: LINKS,
+  commits: COMMITS,
+})

package/tests/context.ts

@@ -86,6 +86,7 @@ const types: AnyTypeSchema[] = [
     flows: [PROJECT_FLOW],
     specifications: [{ category: 'brief', format: SpecificationFormat.Markdown, revisioned: true, type: SPEC }],
     cardTypes: [STORY],
+    scopedCardTypes: true,
   },
   {
     type: STORY,
@@ -118,6 +119,13 @@ export const protocols = makePlanningProtocols({
   guards: [],
 })
 
+/** The same mount with the data-defined schema surface. */
+export const definitionProtocols = makePlanningProtocols({
+  base: { alias: 'test:planning', path: '/planning' },
+  guards: [],
+  definitions: true,
+})
+
 const AUTH = { profileId: PROFILE_ID, userId: 'user-1', entityId: 'acme' } as unknown as Auth
 const entityOf = (id: string): ResolvedEntity => ({ id, slug: id, iamKey: id })
 
@@ -136,6 +144,8 @@ export interface SuiteOptions extends Partial<Pick<PlanningClientOptions, 'poll'
   stores?: boolean
   /** The entity the transport authenticates as. */
   entityId?: string
+  /** Mount the tree with `definitions: true` over a store holding data-defined schemas. */
+  definitions?: boolean
   /** Runs after the server answered a call and before the client sees the answer. */
   after?: (call: Call) => Promise<void>
 }
@@ -193,9 +203,10 @@ export const makeSuite = async (opts: SuiteOptions = {}): Promise<Suite> => {
   const server = makeBasicContext<BasicConfig>({
     ready: false, service: 'client-planning-tests-server', type: AppType.Backend,
   } as BasicConfig)
-  const store = makeMemoryPlanningStore({ sync: opts.sync !== false })
+  const tree = opts.definitions === true ? definitionProtocols : protocols
+  const store = makeMemoryPlanningStore({ sync: opts.sync !== false, schemas: opts.definitions === true })
   appendPlanningService(server, { store, schemas: { types, flows } })
-  server.registerEntrypoints(servePlanningEntrypoints(protocols))
+  server.registerEntrypoints(servePlanningEntrypoints(tree))
   await server.configure().init()
 
   const calls: Call[] = []
@@ -245,7 +256,7 @@ export const makeSuite = async (opts: SuiteOptions = {}): Promise<Suite> => {
   }))
 
   appendPlanningClient(client, {
-    protocols,
+    protocols: tree,
     poll: opts.poll ?? 2,
     schemas: opts.schemas,
     ...(opts.socket === true

package/tests/definitions.spec.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  PlanningSchemaKind, PlanningUnsupported, SchemaOrigin, TransitionAction, WorkcardKind,
+} from '@owlmeans/planning'
+import type { WorkcardTypeSchema } from '@owlmeans/planning'
+import { definitionProtocols, makeSuite, STORY_FLOW } from './context.js'
+
+/** A choir's rehearsal card, defined as data for one project. */
+const REHEARSAL: WorkcardTypeSchema = {
+  type: 'test:rehearsal', kind: WorkcardKind.Card, version: 1, fields: { type: 'object' }, flows: [STORY_FLOW], specifications: [],
+}
+
+describe('@owlmeans/client-planning — data-defined schemas', () => {
+  test('a layer is read once per project and read again after any write', async () => {
+    const suite = await makeSuite({ definitions: true })
+    const project = await suite.project('Spring concert')
+    const definitions = suite.planning.definitions!
+    const reads = () => suite.calls.filter(call => call.alias === definitionProtocols.schema.list.alias).length
+
+    const written = await definitions.define({ types: [REHEARSAL] }, { project: project.id })
+    expect(written.map(record => [record.kind, record.key, record.version, record.project]))
+      .toEqual([[PlanningSchemaKind.Type, REHEARSAL.type, 1, project.id]])
+
+    const before = reads()
+    const layer = await definitions.registry(project.id)
+    await definitions.registry(project.id)
+    expect(reads()).toBe(before + 1)
+    expect(layer.originOf(PlanningSchemaKind.Type, REHEARSAL.type)).toBe(SchemaOrigin.Project)
+    expect((await definitions.bundle()).types.some(type => type.type === REHEARSAL.type)).toBe(false)
+
+    await definitions.putType({ ...REHEARSAL, version: 2, label: 'Rehearsal' }, { project: project.id })
+    expect((await definitions.registry(project.id)).type(REHEARSAL.type).label).toBe('Rehearsal')
+    expect(reads()).toBe(before + 3)
+    await expect(definitions.records()).rejects.toBeInstanceOf(PlanningUnsupported)
+  })
+
+  test('a model of a card resolves its type in its own project\'s layer', async () => {
+    const suite = await makeSuite({ definitions: true })
+    const project = await suite.project('Autumn concert')
+    await suite.planning.definitions!.define({ types: [REHEARSAL] }, { project: project.id })
+    const card = (await suite.local.execute({
+      card: { kind: WorkcardKind.Card, type: REHEARSAL.type, parent: project.id!, title: 'Sectionals' },
+      action: TransitionAction.Create,
+    }, { wait: true })).card!
+
+    const model = await suite.planning.model(card.id!)
+    expect(model.schema().type).toBe(REHEARSAL.type)
+    expect(model.available().map(rule => rule.name)).toEqual(['start', 'reset'])
+  })
+
+  test('a tree declared without definitions has none', async () => {
+    const suite = await makeSuite()
+    expect(suite.planning.definitions).toBeUndefined()
+    expect(suite.client.planning().definitions).toBeUndefined()
+  })
+})