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

package/src/schemas.ts

@@ -5,12 +5,14 @@ import type { ListResult } from '@owlmeans/resource'
 import {
   BODY_MAX, CAUSE_MAX, CODE_MAX, CodeScope, CodeStyle, CommitState, DESCRIPTION_MAX, IntrinsicPolicy,
   IntrinsicStatus, KEY_MAX, LABEL_MAX, MAX_COMMIT_POLL, MAX_LABELS, MAX_PARENTS, MAX_QUERY_LIST,
-  QUERY_TEXT_MAX, REF_MAX, SpecificationFormat, TITLE_MAX, TransitionAction, TYPE_MAX, WorkcardKind,
+  PlanningSchemaKind, QUERY_TEXT_MAX, REF_MAX, SchemaOrigin, SchemaWriteMode, SpecificationFormat,
+  TITLE_MAX, TransitionAction, TYPE_MAX, WorkcardKind,
 } from './consts.js'
 import type {
   AnyTypeSchema, CodePolicy, CommitEvent, CommitFeedQuery, CommitQuery, CommitStatus, ExecuteRequest,
   PlanningSchemaBundle, ProjectTypeSchema, Relationship, RelationshipDraft, RelationshipQueryWire,
-  RelationshipType, RevisionsQuery, Specification, SpecificationQueryWire, SpecificationRevision,
+  RelationshipType, RevisionsQuery, SchemaDefineRequest, SchemaKey, SchemaListQuery, ScopedSchemaBundle,
+  ScopedSchemaRecord, Specification, SpecificationQueryWire, SpecificationRevision,
   SpecificationRevisionList, SpecificationSlot, StatusDefinition, StatusFlowSchema,
   StatusTransitionRule, SummaryQueryWire, SummaryView, Transition, TransitionActor, TransitionCommit,
   TransitionExecution, TransitionParams, TransitionQueryWire, TransitionReceiptView, Workcard,
@@ -260,6 +262,7 @@ export const StatusFlowSchemaSchema = cast<StatusFlowSchema>({
     statuses: { type: 'array', minItems: 1, items: StatusDefinitionSchema },
     transitions: { type: 'array', items: StatusTransitionRuleSchema },
     label: { type: 'string', maxLength: TITLE_MAX, nullable: true },
+    overridable: { type: 'boolean', nullable: true },
   },
   required: ['id', 'version', 'statuses', 'transitions'],
   additionalProperties: false,
@@ -322,6 +325,7 @@ const typeProperties = {
   labels: { type: 'array', items: Label, nullable: true },
   code: { ...CodePolicySchema, nullable: true },
   label: { type: 'string', maxLength: TITLE_MAX, nullable: true },
+  overridable: { type: 'boolean', nullable: true },
 }
 
 const typeRequired = ['type', 'kind', 'version', 'fields', 'flows', 'specifications']
@@ -343,6 +347,7 @@ export const ProjectTypeSchemaSchema = cast<ProjectTypeSchema>({
     kind: { type: 'string', enum: [WorkcardKind.Project] },
     cardTypes: { type: 'array', items: TypeKey },
     projectTypes: { type: 'array', items: TypeKey, nullable: true },
+    scopedCardTypes: { type: 'boolean', nullable: true },
   },
   required: [...typeRequired, 'cardTypes'],
   additionalProperties: false,
@@ -356,6 +361,7 @@ export const AnyTypeSchemaSchema = cast<AnyTypeSchema>({
     kind: WorkcardKindSchema,
     cardTypes: { type: 'array', items: TypeKey, nullable: true },
     projectTypes: { type: 'array', items: TypeKey, nullable: true },
+    scopedCardTypes: { type: 'boolean', nullable: true },
   },
   required: typeRequired,
   additionalProperties: false,
@@ -372,6 +378,96 @@ export const PlanningSchemaBundleSchema = cast<PlanningSchemaBundle>({
   additionalProperties: false,
 })
 
+// ─── Data-defined (scoped) schemas ───────────────────────────────────────────────────────────────
+
+export const PlanningSchemaKindSchema = cast<PlanningSchemaKind>({ type: 'string', enum: Object.values(PlanningSchemaKind) })
+export const SchemaOriginSchema = cast<SchemaOrigin>({ type: 'string', enum: Object.values(SchemaOrigin) })
+export const SchemaWriteModeSchema = cast<SchemaWriteMode>({ type: 'string', enum: Object.values(SchemaWriteMode) })
+
+export const ScopedSchemaRecordSchema = cast<ScopedSchemaRecord>({
+  type: 'object',
+  properties: {
+    id: OptionalId,
+    entityId: Id,
+    project: OptionalId,
+    kind: PlanningSchemaKindSchema,
+    key: TypeKey,
+    version: { type: 'number', minimum: 1 },
+    /** A card type or a flow — its own schema is applied by `assertTypeSchema` / `assertFlowSchema`. */
+    definition: OpenObject,
+    retired: { type: 'boolean', nullable: true },
+    rev: { type: 'number', minimum: 0, nullable: true },
+    createdAt: IsoDate,
+    updatedAt: OptionalIsoDate,
+    by: { ...TransitionActorSchema, nullable: true },
+  },
+  required: ['entityId', 'kind', 'key', 'version', 'definition', 'createdAt'],
+  additionalProperties: false,
+})
+
+export const SchemaKeySchema = cast<SchemaKey>({
+  type: 'object',
+  properties: { kind: PlanningSchemaKindSchema, key: TypeKey },
+  required: ['kind', 'key'],
+  additionalProperties: false,
+})
+
+const originMap = () => ({ type: 'object', additionalProperties: { type: 'string', enum: Object.values(SchemaOrigin) }, required: [] })
+const keyList = () => ({ type: 'array', items: TypeKey })
+
+export const ScopedSchemaBundleSchema = cast<ScopedSchemaBundle>({
+  type: 'object',
+  properties: {
+    version: { type: 'number', minimum: 1 },
+    types: { type: 'array', items: AnyTypeSchemaSchema },
+    flows: { type: 'array', items: StatusFlowSchemaSchema },
+    scope: {
+      type: 'object',
+      properties: { entityId: Id, project: OptionalId },
+      required: ['entityId'],
+      additionalProperties: false,
+      nullable: true,
+    },
+    revision: { type: 'number', minimum: 0, nullable: true },
+    origins: {
+      type: 'object',
+      properties: { types: originMap(), flows: originMap() },
+      required: ['types', 'flows'],
+      additionalProperties: false,
+      nullable: true,
+    },
+    retired: {
+      type: 'object',
+      properties: { types: keyList(), flows: keyList() },
+      required: ['types', 'flows'],
+      additionalProperties: false,
+      nullable: true,
+    },
+  },
+  required: ['version', 'types', 'flows'],
+  additionalProperties: false,
+})
+
+export const SchemaListQuerySchema = cast<SchemaListQuery>({
+  type: 'object',
+  properties: { project: OptionalId },
+  required: [],
+  additionalProperties: false,
+})
+
+export const SchemaDefineRequestSchema = cast<SchemaDefineRequest>({
+  type: 'object',
+  properties: {
+    project: OptionalId,
+    mode: nullable(SchemaWriteModeSchema),
+    types: { type: 'array', maxItems: MAX_QUERY_LIST, items: WorkcardTypeSchemaSchema, nullable: true },
+    flows: { type: 'array', maxItems: MAX_QUERY_LIST, items: StatusFlowSchemaSchema, nullable: true },
+    retire: { type: 'array', maxItems: MAX_QUERY_LIST, items: SchemaKeySchema, nullable: true },
+  },
+  required: [],
+  additionalProperties: false,
+})
+
 // ─── Execution ───────────────────────────────────────────────────────────────────────────────────
 
 export const WorkcardDraftSchema = cast<WorkcardDraft>({

package/src/types.ts

@@ -1,12 +1,11 @@
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
-import type { EntrypointProtocol, OpenRequest, OpenValue } from '@owlmeans/entrypoint'
 import type { Criteria, ListOptions, ListResult, ResourceRecord } from '@owlmeans/resource'
-import type { RouteParent } from '@owlmeans/route'
 import type { AnySchema, ValidateFunction } from 'ajv'
 import type {
-  CodeScope, CodeStyle, CommitState, IntrinsicPolicy, IntrinsicStatus, SpecificationFormat,
-  TransitionAction, WorkcardKind,
+  CodeScope, CodeStyle, CommitState, IntrinsicPolicy, IntrinsicStatus, PlanningSchemaKind, SchemaOrigin,
+  SchemaWriteMode, SpecificationFormat, TransitionAction, WorkcardKind,
 } from './consts.js'
+import type { WorkcardModel } from './models/types.js'
 
 // ─── Records ─────────────────────────────────────────────────────────────────────────────────────
 
@@ -121,9 +120,7 @@ export interface TransitionCommit {
  * Every key carries a NEW VALUE, never a delta. `fields` and `flows` merge shallowly into the
  * card's; every other key replaces. Clearing is `Transition.unset`.
  */
-export type WorkcardChanges =
-  & Partial<Omit<Workcard, 'id' | 'kind' | 'type' | 'entityId' | 'seq' | 'head' | 'createdAt'>>
-  & Partial<Pick<Specification, 'category' | 'format' | 'body' | 'ref' | 'revision' | 'version' | 'bodyChars'>>
+export interface WorkcardChanges extends Partial<Omit<Workcard, 'id' | 'kind' | 'type' | 'entityId' | 'seq' | 'head' | 'createdAt'>>, Partial<Pick<Specification, 'category' | 'format' | 'body' | 'ref' | 'revision' | 'version' | 'bodyChars'>> {}
 
 /** The event. Append-only, never edited; folding every transition of a card in `seq` order IS the card. */
 export interface Transition extends ResourceRecord {
@@ -186,6 +183,11 @@ export interface StatusFlowSchema {
   statuses: StatusDefinition[]
   transitions: StatusTransitionRule[]
   label?: string
+  /**
+   * A code-registered flow is sealed against a data-defined override unless it says so. Meaningless
+   * on a data-defined flow: a project may override any organization-wide record.
+   */
+  overridable?: boolean
 }
 
 export interface SpecificationSlot {
@@ -243,12 +245,22 @@ export interface WorkcardTypeSchema {
   labels?: string[]
   code?: CodePolicy
   label?: string
+  /**
+   * A code-registered card type is sealed against a data-defined override unless it says so.
+   * Meaningless on a data-defined type: a project may override any organization-wide record.
+   */
+  overridable?: boolean
 }
 
 export interface ProjectTypeSchema extends Omit<WorkcardTypeSchema, 'kind'> {
   kind: WorkcardKind.Project
   cardTypes: string[]
   projectTypes?: string[]
+  /**
+   * The project admits cards of data-defined types (organization-wide or its own) beside the
+   * `cardTypes` it lists.
+   */
+  scopedCardTypes?: boolean
 }
 
 export type AnyTypeSchema = WorkcardTypeSchema | ProjectTypeSchema
@@ -278,6 +290,156 @@ export interface PlanningSchemaRegistry {
   load: (bundle: PlanningSchemaBundle) => void
 }
 
+// ─── Data-defined (scoped) schemas ───────────────────────────────────────────────────────────────
+
+/** The layer a record belongs to: an organization, and optionally one of its project cards. */
+export interface SchemaScope {
+  entityId: string
+  /** A project card id; the organization-wide layer when omitted. */
+  project?: string
+}
+
+/**
+ * A card type or a status flow defined as data — organization-wide, or scoped to one project.
+ *
+ * `version` is the record's compare-and-set token and is also written into the declaration's own
+ * `version`: a write lands only at its layer's next version (1 for a new key).
+ */
+export interface ScopedSchemaRecord extends ResourceRecord {
+  id?: string
+  entityId: string
+  /** A project card id; absent on an organization-wide record. */
+  project?: string
+  kind: PlanningSchemaKind
+  /** The type key or the flow id. */
+  key: string
+  version: number
+  /** A `WorkcardTypeSchema` of kind `card`, or a `StatusFlowSchema`. */
+  definition: WorkcardTypeSchema | StatusFlowSchema
+  /**
+   * Retired: offered for nothing new, still resolved for what already uses it. A retired record
+   * gives way to a live declaration of the same key in a lower layer.
+   */
+  retired?: boolean
+  /** The organization's schema revision this write landed at — assigned by the store. */
+  rev?: number
+  createdAt: string
+  updatedAt?: string
+  by?: TransitionActor
+}
+
+export interface ScopedSchemaWhere {
+  entityId: string
+  /** A project id — that project's layer; `null` — the organization-wide layer; omitted — every layer. */
+  project?: string | null
+  kind?: PlanningSchemaKind
+  key?: string | string[]
+  retired?: boolean
+}
+
+/**
+ * The optional port a store implements to hold data-defined types and flows. A store without it
+ * resolves every type and flow from the code registry alone.
+ */
+export interface SchemaStore {
+  list: (where: ScopedSchemaWhere) => Promise<ScopedSchemaRecord[]>
+  /**
+   * Write one record — compare-and-set on `version`: the stored record of the same layer and key
+   * must be at `record.version - 1` (absent for version 1). Bumps the organization's revision.
+   *
+   * @throws {SchemaConflict}
+   */
+  put: (record: ScopedSchemaRecord) => Promise<ScopedSchemaRecord>
+  /** Remove a project's whole layer (its project was purged). Bumps the revision. */
+  purge: (where: { entityId: string, project: string }) => Promise<number>
+  /** The organization's monotonic schema revision — 0 before its first write. */
+  revision: (entityId: string) => Promise<number>
+  /** Hear of every write of an organization's records, from this process and — where the store can — others. */
+  watch?: (listener: (entityId: string) => void) => Unsubscribe
+}
+
+export interface SchemaKey {
+  kind: PlanningSchemaKind
+  key: string
+}
+
+/** What a scoped bundle adds, per kind: where each key resolved from, and which keys are retired. */
+export interface ScopedSchemaOrigins {
+  types: Record<string, SchemaOrigin>
+  flows: Record<string, SchemaOrigin>
+}
+
+export interface ScopedSchemaRetired {
+  types: string[]
+  flows: string[]
+}
+
+/**
+ * A bundle resolved for one layer: the code registry, overlaid by the organization's records, then
+ * by the project's. Retired declarations stay in `types`/`flows` (existing cards still resolve them)
+ * and are listed in `retired`. Readers of the plain bundle ignore the extra keys.
+ */
+export interface ScopedSchemaBundle extends PlanningSchemaBundle {
+  scope?: SchemaScope
+  /** The organization's schema revision the bundle was resolved at. */
+  revision?: number
+  origins?: ScopedSchemaOrigins
+  retired?: ScopedSchemaRetired
+}
+
+/** A read-only registry over one resolved layer. Its `register*` and `load` refuse. */
+export interface ScopedSchemaRegistry extends PlanningSchemaRegistry {
+  scope: SchemaScope
+  revision: number
+  /** `undefined` for a key the layer does not resolve. */
+  originOf: (kind: PlanningSchemaKind, key: string) => SchemaOrigin | undefined
+  isRetired: (kind: PlanningSchemaKind, key: string) => boolean
+  bundle: () => ScopedSchemaBundle
+}
+
+/** Declarations written together — flows first, so a type may name a flow defined beside it. */
+export interface SchemaDeclarations {
+  types?: WorkcardTypeSchema[]
+  flows?: StatusFlowSchema[]
+}
+
+export interface SchemaWriteOptions {
+  /** A project card id — that project's layer; the organization-wide layer when omitted. */
+  project?: string
+}
+
+/**
+ * Data-defined types and flows — present on a facade whose store implements
+ * {@link PlanningStore.schemas}. Only card types and flows are data-defined; projects and
+ * specifications always resolve in code.
+ */
+export interface PlanningDefinitions {
+  /** The layer resolved: the organization-wide one, or a project's (which includes it). */
+  bundle: (project?: string) => Promise<ScopedSchemaBundle>
+  registry: (project?: string) => Promise<ScopedSchemaRegistry>
+  /** The records of one layer (`project: null` the organization's; omitted — every layer). */
+  records: (opts?: { project?: string | null, kind?: PlanningSchemaKind, retired?: boolean }) => Promise<ScopedSchemaRecord[]>
+  /**
+   * Compare-and-set: `type.version` must be the layer's next version (1 for a new key).
+   *
+   * @throws {SchemaConflict | SchemaSealed | SchemaInvalid | WorkcardNotFound}
+   */
+  putType: (type: WorkcardTypeSchema, opts?: SchemaWriteOptions) => Promise<ScopedSchemaRecord>
+  /** Compare-and-set, as {@link putType}. */
+  putFlow: (flow: StatusFlowSchema, opts?: SchemaWriteOptions) => Promise<ScopedSchemaRecord>
+  /** Every declaration at its layer's next version — flows first, then types. */
+  define: (declarations: SchemaDeclarations, opts?: SchemaWriteOptions) => Promise<ScopedSchemaRecord[]>
+  /** Only the keys the layer lacks, at version 1 — idempotent. */
+  seed: (declarations: SchemaDeclarations, opts?: SchemaWriteOptions) => Promise<ScopedSchemaRecord[]>
+  /**
+   * Retire a key at a layer. Existing cards keep resolving it; nothing new is created with it.
+   *
+   * @throws {SchemaInUse} a flow still resolved by a live type of an affected layer
+   * @throws {UnknownWorkcardType | UnknownStatusFlow} the layer holds no record of the key
+   */
+  retire: (kind: PlanningSchemaKind, key: string, opts?: SchemaWriteOptions) => Promise<ScopedSchemaRecord>
+}
+
 // ─── Execution and receipts ──────────────────────────────────────────────────────────────────────
 
 export interface WorkcardDraft {
@@ -375,7 +537,7 @@ export interface CommitFilter {
   kind?: WorkcardKind
 }
 
-export type Unsubscribe = () => void
+export interface Unsubscribe { (): void }
 
 export interface CommitSource {
   status: (transition: string) => Promise<CommitStatus>
@@ -389,7 +551,8 @@ export interface CommitSource {
 export interface TransitionWhere {
   entityId: string
   card?: string | string[]
-  project?: string
+  /** One project, or any of several. */
+  project?: string | string[]
   sinceSeq?: number
   state?: CommitState
   action?: TransitionAction | TransitionAction[]
@@ -456,6 +619,8 @@ export interface RelationshipWhere {
   from?: string | string[]
   to?: string | string[]
   type?: string | string[]
+  /** The project an edge is filed under. A store that ignores it is narrowed by the facade. */
+  project?: string | string[]
 }
 
 export interface RelationshipStore {
@@ -482,6 +647,8 @@ export interface PlanningStore {
   specs?: SpecificationStore
   links?: RelationshipStore
   commits?: CommitSource
+  /** Data-defined types and flows. Without it every type and flow resolves in code. */
+  schemas?: SchemaStore
 }
 
 // ─── Queries ─────────────────────────────────────────────────────────────────────────────────────
@@ -613,6 +780,29 @@ export interface RevisionsQuery {
   limit?: number
 }
 
+export interface SchemaListQuery {
+  /** A project card id — that project's layer; the organization-wide one when omitted. */
+  project?: string
+}
+
+/** The one write of data-defined types and flows over the wire. */
+export interface SchemaDefineRequest {
+  /** A project card id — that project's layer; the organization-wide one when omitted. */
+  project?: string
+  /** `define` when omitted. */
+  mode?: SchemaWriteMode
+  types?: WorkcardTypeSchema[]
+  flows?: StatusFlowSchema[]
+  /** Keys retired at the layer after the declarations are written. */
+  retire?: SchemaKey[]
+}
+
+/** What a `schema.define` answers: the records it wrote, and the layer as it resolves afterwards. */
+export interface SchemaDefineReply {
+  records: ScopedSchemaRecord[]
+  bundle: ScopedSchemaBundle
+}
+
 // ─── Facade, scope, service, plugin seam ─────────────────────────────────────────────────────────
 
 export interface PlanningScope {
@@ -622,6 +812,12 @@ export interface PlanningScope {
   service?: string
   channel?: string
   actor?: TransitionActor
+  /**
+   * The only project cards this scope may see and write — the projects themselves and every card
+   * whose `parents` name one (a card's document through its card). Every project when omitted.
+   * Advisory on a client, where the server decides.
+   */
+  projects?: string[]
 }
 
 export interface PlanningFacade {
@@ -652,6 +848,8 @@ export interface PlanningFacade {
   commits: CommitSource
   execute: (exec: TransitionExecution, opts?: ExecuteOptions) => Promise<TransitionReceipt>
   model: <T extends Workcard = Workcard>(card: T | string) => Promise<WorkcardModel<T>>
+  /** Data-defined types and flows — present only where the store holds them. */
+  definitions?: PlanningDefinitions
 }
 
 export interface WithPlanningService {
@@ -717,120 +915,3 @@ export interface PlanningService {
   /** Runs the ordered `after` chain — called by the process that FOLDED the transition. */
   committed: (event: CommitEvent) => Promise<void>
 }
-
-// ─── Models ──────────────────────────────────────────────────────────────────────────────────────
-
-export interface ExecuteMeta {
-  actor?: TransitionActor
-  cause?: string
-  key?: string
-  expectSeq?: number | null
-}
-
-export type ModelExecuteOptions = ExecuteOptions & ExecuteMeta
-
-export interface SpecificationWriteOptions extends ModelExecuteOptions {
-  format?: SpecificationFormat
-  version?: number
-  ref?: string
-  /** The title a new document gets; the category when omitted. */
-  title?: string
-  /** The specification type; resolved from the slot and the registry when omitted. */
-  type?: string
-}
-
-export interface WorkcardModel<T extends Workcard = Workcard> {
-  record: T
-  id: string
-  kind: WorkcardKind
-  type: string
-  schema: () => AnyTypeSchema
-  flow: (id?: string) => StatusFlowSchema
-  statusOf: (flowId?: string) => string
-  intrinsicOf: (flowId?: string) => IntrinsicStatus
-  can: (transition: string, flowId?: string) => boolean
-  available: (flowId?: string) => StatusTransitionRule[]
-  pending: () => boolean
-  transit: (transition: string, changes?: WorkcardChanges, opts?: ModelExecuteOptions & { flow?: string }) => Promise<TransitionReceipt>
-  update: (changes: WorkcardChanges, opts?: ModelExecuteOptions & { unset?: string[] }) => Promise<TransitionReceipt>
-  remove: (opts?: ModelExecuteOptions) => Promise<TransitionReceipt>
-  link: (type: string, to: string, fields?: Record<string, unknown>, opts?: ModelExecuteOptions) => Promise<TransitionReceipt>
-  unlink: (type: string, to: string, opts?: ModelExecuteOptions) => Promise<TransitionReceipt>
-  children: (query?: Omit<WorkcardQuery, 'parent'>) => Promise<ListResult<Workcard>>
-  relationships: (query?: RelationshipQuery) => Promise<ListResult<Relationship>>
-  transitions: (query?: Omit<TransitionQuery, 'card'>) => Promise<ListResult<Transition>>
-  specification: (category: string) => Promise<Specification | null>
-  specifications: (query?: SpecificationQuery) => Promise<ListResult<Specification>>
-  revisions: (category: string, limit?: number) => Promise<SpecificationRevision[]>
-  /** Create the slot's document, or revise it when it already exists. */
-  write: (category: string, body: string, opts?: SpecificationWriteOptions) => Promise<TransitionReceipt>
-  reload: () => Promise<WorkcardModel<T>>
-}
-
-export interface ProjectModel extends WorkcardModel<Project> {
-  cards: (query?: Omit<WorkcardQuery, 'within' | 'kind'>) => Promise<ListResult<Workcard>>
-  projects: (query?: Omit<WorkcardQuery, 'within' | 'kind'>) => Promise<ListResult<Workcard>>
-  summary: (query?: Omit<SummaryQuery, 'parents'>) => Promise<IntrinsicCounts>
-  /** A `delete` of the project — the store removes everything under it. */
-  purge: (opts?: ModelExecuteOptions) => Promise<TransitionReceipt>
-  reload: () => Promise<ProjectModel>
-}
-
-export interface SpecificationModel extends WorkcardModel<Specification> {
-  body: () => string | undefined
-  revise: (body: string, opts?: ModelExecuteOptions & { version?: number, ref?: string }) => Promise<TransitionReceipt>
-  history: (limit?: number) => Promise<SpecificationRevision[]>
-  reload: () => Promise<SpecificationModel>
-}
-
-// ─── Protocol tree ───────────────────────────────────────────────────────────────────────────────
-
-export interface PlanningBaseOptions {
-  /** The base alias every leaf alias derives from (`planningAliases`). */
-  alias: string
-  /** Defaults to `PLANNING_PATH`. */
-  path?: string
-  parent?: RouteParent
-  service?: string
-}
-
-export interface PlanningProtocolOptions {
-  base: PlanningBaseOptions
-  /** The guard(s) the base carries; every HTTP leaf inherits them. */
-  guards: string | readonly string[]
-  gate?: { alias: string, params?: string | readonly string[] }
-  /**
-   * The socket base the commit feed hangs under. The feed inherits THAT base's guards; the
-   * planning base when omitted.
-   */
-  socketBase?: RouteParent
-}
-
-export interface PlanningProtocols {
-  base: EntrypointProtocol<OpenRequest, OpenValue>
-  schema: {
-    list: EntrypointProtocol<{}, PlanningSchemaBundle>
-  }
-  card: {
-    list: EntrypointProtocol<{ query: WorkcardQueryWire }, ListResult<Workcard>>
-    summary: EntrypointProtocol<{ query: SummaryQueryWire }, SummaryView>
-    get: EntrypointProtocol<{ params: WorkcardParams }, Workcard>
-    transitions: EntrypointProtocol<{ params: WorkcardParams, query: TransitionQueryWire }, ListResult<Transition>>
-    specifications: EntrypointProtocol<{ params: WorkcardParams, query: SpecificationQueryWire }, ListResult<Specification>>
-  }
-  spec: {
-    get: EntrypointProtocol<{ params: WorkcardParams }, Specification>
-    revisions: EntrypointProtocol<{ params: WorkcardParams, query: RevisionsQuery }, SpecificationRevisionList>
-  }
-  link: {
-    list: EntrypointProtocol<{ query: RelationshipQueryWire }, ListResult<Relationship>>
-  }
-  transition: {
-    get: EntrypointProtocol<{ params: TransitionParams }, Transition>
-  }
-  execute: EntrypointProtocol<{ body: ExecuteRequest }, TransitionReceiptView>
-  commit: {
-    get: EntrypointProtocol<{ params: TransitionParams, query: CommitQuery }, CommitStatus>
-    events: EntrypointProtocol<{ query: CommitFeedQuery }, CommitEvent>
-  }
-}

package/src/utils.ts

@@ -0,0 +1,9 @@
+import { planningAliasHelper } from './aliases.js'
+import type { PlanningAliases, PlanningDefinitionAliases } from './aliases/types.js'
+
+/** @deprecated compat:factory-refactor — use `planningAliasHelper.planningAliases(…)` */
+export const planningAliases = (base: string): PlanningAliases => planningAliasHelper.planningAliases(base)
+
+/** @deprecated compat:factory-refactor — use `planningAliasHelper.planningDefinitionAliases(…)` */
+export const planningDefinitionAliases = (base: string): PlanningDefinitionAliases =>
+  planningAliasHelper.planningDefinitionAliases(base)