@bpmn-nova/studio 0.3.1-preview → 0.3.2-preview

package/README.md

@@ -4,7 +4,7 @@ BPMN Nova 的 Vanilla JavaScript / TypeScript 完整入口，提供流程设计
 
 > **English summary:** The complete framework-neutral BPMN Nova package for process design, viewing, approval traces, themes, properties, and pure SVG export.
 
-> 当前版本为 `0.3.1-preview`。请使用 `@preview` 安装，并在生产接入前验证目标 BPMN XML 与引擎扩展。
+> 当前版本为 `0.3.2-preview`。请使用 `@preview` 安装，并在生产接入前验证目标 BPMN XML 与引擎扩展。
 
 ![BPMN Nova 流程设计器](https://raw.githubusercontent.com/daxiangme/bpmn-nova/dev/docs/assets/bpmn-nova-designer.jpg)
 
@@ -27,6 +27,8 @@ import '@bpmn-nova/studio/styles.css'
 
 BPMN Nova 不会在 JavaScript 中隐式注入 CSS。视觉容器必须有明确高度。
 
+使用代码生成助手或 IDE Agent 接入时，从随包的 `llms.txt` 开始；需要完整接口和定制资料时再读取 `llms-full.txt`。两份文件都包含在 npm tarball 中，不依赖源码仓库可见性。
+
 ## 流程设计
 
 ```html
@@ -45,10 +47,16 @@ const model = createEmptyProcess('flowable')
 model.id = 'Process_PurchaseApproval'
 model.name = '采购申请审批流程'
 
-const studio = createStudioController({ model })
+const studio = createStudioController({
+  model,
+  allowedNodeTypes: ['startEvent', 'userTask', 'exclusiveGateway', 'endEvent'],
+  allowedEdgeTypes: ['sequenceFlow'],
+})
 const shell = createStudioShell({
   container: document.querySelector('#studio'),
   studio,
+  mode: 'design',
+  allowedModes: ['design'],
   theme: 'auto',
 })
 
@@ -59,6 +67,40 @@ shell.destroy()
 studio.destroy()
 ```
 
+`allowedNodeTypes` 与 `allowedEdgeTypes` 同时约束 XML 导入、Palette、连接、快捷新增、模板和节点类型转换；不传时开放 Nova 当前支持的全部图元。`allowedModes` 控制默认工作台显示和允许切换的模式。不传 Runtime 时实例模式保持空运行事实，不会注入演示审批数据。
+
+## 嵌入宿主工作台
+
+默认 `BpmnStudioShell` 仍是包含 Header、Palette、Canvas、Properties 和 Statusbar 的完整工作台。宿主要复用自己的业务属性面板时，应显式隐藏 Nova 右侧区域，并把业务面板作为 Nova 根节点的外部兄弟区域：
+
+```js
+const shell = createStudioShell({
+  container: novaHost,
+  studio,
+  mode: 'design',
+  allowedModes: ['design'],
+  regions: { right: 'hidden' },
+  slots: {
+    headerStart({ container, actions, getState, subscribe }) {
+      // 在 Nova Header 左侧挂载宿主的返回入口、业务图标、流程名称和类型。
+      // 完整替换 Header 时改用 slots.header，并继续调用 actions。
+    },
+  },
+  theme: 'auto',
+})
+
+shell.setRegions({ right: 'default' })
+shell.actions.undo()
+shell.actions.redo()
+shell.actions.fitView()
+const issues = shell.actions.validate()
+const xml = shell.actions.exportXml('flowable')
+```
+
+`regions` 支持 `header`、`left`、`right`、`footer` 的 `default | hidden` 状态；隐藏区域不占布局轨道。`setRegions()` 原地更新默认 Shell，不重建 Controller 或 Canvas。`layout()` 是完整布局替换，不能与 `regions` 同时使用。
+
+`shell.actions` 只封装撤销、重做、布局、视图、校验和 BPMN/SVG 导入导出。宿主的保存草稿、发布、权限、文件选择和服务端事务不属于 Nova Actions。
+
 ## 只读 Viewer
 
 ```js
@@ -227,12 +269,12 @@ import { activitiProfile } from '@bpmn-nova/studio/activiti'
 
 ## 文档与 AI
 
+- npm 包内 `llms.txt`：可执行安装入口
+- npm 包内 `llms-full.txt`：完整 AI 上下文
 - [项目首页](https://github.com/daxiangme/bpmn-nova)
 - [快速开始](https://github.com/daxiangme/bpmn-nova/blob/dev/docs/GETTING-STARTED.md)
 - [公开 Interface](https://github.com/daxiangme/bpmn-nova/blob/dev/docs/API.md)
 - [自定义指南](https://github.com/daxiangme/bpmn-nova/blob/dev/docs/CUSTOMIZATION.md)
-- [AI 接入入口](https://raw.githubusercontent.com/daxiangme/bpmn-nova/dev/llms.txt)
-- [AI 完整上下文](https://raw.githubusercontent.com/daxiangme/bpmn-nova/dev/llms-full.txt)
 
 ## 能力边界
 

package/dist/canvas.js

@@ -80,6 +80,7 @@ export class BpmnCanvas {
       },
       onStartConnect: (node) => studio.startConnect(node.id),
       canConnect: (source, target) => canCreateSequenceFlow(studio.model, source.id, target.id),
+      canCreateNodeType: (nodeType) => studio.allowsNodeType(nodeType),
       onQuickAdd: (source, type, preset) => studio.commands.quickAdd(source.id, type, preset),
       onDeleteNode: (node) => studio.commands.remove({ kind: 'node', id: node.id }),
       onUngroup: (node) => studio.commands.ungroup(node.id),
@@ -521,7 +522,7 @@ export class BpmnCanvas {
       { id: 'distribute-vertical', iconId: 'ui.distributeVertical', title: '垂直等距', action: () => actions.distribute('vertical'), disabled: nodes.length < 3 },
     ];
     this._selectionToolbar.append(
-      button('group', 'ui.layoutSelection', '创建分组', actions.group, { label: '创建分组', disabled: !groupableNodes.length || groupableNodes.length !== diagramNodes.length }),
+      button('group', 'ui.layoutSelection', '创建分组', actions.group, { label: '创建分组', disabled: this.studio.allowsNodeType?.('group') === false || !groupableNodes.length || groupableNodes.length !== diagramNodes.length }),
       separator(),
       menu('align', 'ui.alignCenterHorizontal', '对齐选区', alignmentItems, nodes.length < 2),
       menu('distribute', 'ui.distributeHorizontal', '等距分布', distributeItems, nodes.length < 3),

package/dist/context-menu.js

@@ -104,7 +104,7 @@ function multiActions(context) {
     execute: ({ studio }) => studio.arrangeSelection({ type: 'align', alignment }),
   }));
   actions.push(
-    action({ id: 'selection.group', label: '创建分组', iconId: 'ui.layoutSelection', group: 'layout', disabled: !groupableNodes.length || groupableNodes.length !== diagramNodes.length, execute: ({ studio }) => studio.commands.groupSelection() }),
+    action({ id: 'selection.group', label: '创建分组', iconId: 'ui.layoutSelection', group: 'layout', disabled: context.studio.allowsNodeType?.('group') === false || !groupableNodes.length || groupableNodes.length !== diagramNodes.length, execute: ({ studio }) => studio.commands.groupSelection() }),
     action({ id: 'selection.distribute.horizontal', label: '水平等距', iconId: 'ui.distributeHorizontal', group: 'distribute', disabled: nodes.length < 3, execute: ({ studio }) => studio.arrangeSelection({ type: 'distribute', axis: 'horizontal' }) }),
     action({ id: 'selection.distribute.vertical', label: '垂直等距', iconId: 'ui.distributeVertical', group: 'distribute', disabled: nodes.length < 3, execute: ({ studio }) => studio.arrangeSelection({ type: 'distribute', axis: 'vertical' }) }),
     action({ id: 'selection.layout', label: '美化选区', iconId: 'ui.layoutSelection', group: 'layout', disabled: nodes.length < 2, execute: ({ studio }) => studio.arrangeSelection({ type: 'layout' }) }),

package/dist/controller.js

@@ -1,6 +1,7 @@
 import {
   applyContainmentOperation,
   CONTAINMENT_LIMITS,
+  EDGE_DEFINITIONS,
   HistoryStack,
   LAYOUT_DENSITIES,
   NODE_DEFINITIONS,
@@ -58,9 +59,38 @@ function mergeNodePreset(preset = {}) {
   };
 }
 
+function normalizeAllowedNodeTypes(allowedNodeTypes) {
+  if (allowedNodeTypes === undefined || allowedNodeTypes === null) return null;
+  if (typeof allowedNodeTypes === 'string' || typeof allowedNodeTypes[Symbol.iterator] !== 'function') {
+    throw new Error('allowedNodeTypes must be an iterable of BPMN node types.');
+  }
+  const normalized = new Set(allowedNodeTypes);
+  for (const nodeType of normalized) {
+    if (!NODE_DEFINITIONS[nodeType] || nodeType === 'generic') {
+      throw new Error(`Unknown allowed BPMN node type: ${nodeType}`);
+    }
+  }
+  return normalized;
+}
+
+function normalizeAllowedEdgeTypes(allowedEdgeTypes) {
+  if (allowedEdgeTypes === undefined || allowedEdgeTypes === null) return null;
+  if (typeof allowedEdgeTypes === 'string' || typeof allowedEdgeTypes[Symbol.iterator] !== 'function') {
+    throw new Error('allowedEdgeTypes must be an iterable of BPMN edge types.');
+  }
+  const normalized = new Set(allowedEdgeTypes);
+  for (const edgeType of normalized) {
+    if (!EDGE_DEFINITIONS[edgeType]) throw new Error(`Unknown allowed BPMN edge type: ${edgeType}`);
+  }
+  return normalized;
+}
+
 export class BpmnStudioController {
-  constructor({ model, historyLimit = 80, extensions = [], propertiesProfile = 'business' } = {}) {
+  constructor({ model, historyLimit = 80, extensions = [], propertiesProfile = 'business', allowedNodeTypes = null, allowedEdgeTypes = null } = {}) {
     if (!model) throw new Error('BpmnStudioController requires a model.');
+    this._allowedNodeTypes = normalizeAllowedNodeTypes(allowedNodeTypes);
+    this._allowedEdgeTypes = normalizeAllowedEdgeTypes(allowedEdgeTypes);
+    this._assertAllowedModel(model);
     this._model = model;
     this.history = new HistoryStack(historyLimit);
     this.selection = { kind: 'process', id: model.id };
@@ -108,6 +138,32 @@ export class BpmnStudioController {
 
   get model() { return this._model; }
 
+  allowsNodeType(nodeType) {
+    return Boolean(NODE_DEFINITIONS[nodeType])
+      && nodeType !== 'generic'
+      && (!this._allowedNodeTypes || this._allowedNodeTypes.has(nodeType));
+  }
+
+  allowsEdgeType(edgeType) {
+    return Boolean(EDGE_DEFINITIONS[edgeType])
+      && (!this._allowedEdgeTypes || this._allowedEdgeTypes.has(edgeType));
+  }
+
+  _assertAllowedModel(model) {
+    if (this._allowedNodeTypes) {
+      const unsupportedNode = model?.nodes?.find((node) => !this._allowedNodeTypes.has(node.type));
+      if (unsupportedNode) {
+        throw new Error(`BPMN node type is not allowed: ${unsupportedNode.type} (${unsupportedNode.id})`);
+      }
+    }
+    if (this._allowedEdgeTypes) {
+      const unsupportedEdge = model?.edges?.find((edge) => !this._allowedEdgeTypes.has(edge.type || 'sequenceFlow'));
+      if (unsupportedEdge) {
+        throw new Error(`BPMN edge type is not allowed: ${unsupportedEdge.type || 'sequenceFlow'} (${unsupportedEdge.id})`);
+      }
+    }
+  }
+
   getState() {
     return {
       model: cloneModel(this._model),
@@ -118,6 +174,8 @@ export class BpmnStudioController {
       canRedo: this.history.canRedo,
       engine: this._model.engine,
       propertiesProfile: this.propertiesProfile,
+      allowedNodeTypes: this._allowedNodeTypes ? [...this._allowedNodeTypes] : null,
+      allowedEdgeTypes: this._allowedEdgeTypes ? [...this._allowedEdgeTypes] : null,
       activeScopeId: this.activeScopeId,
       scopePath: getScopePath(this._model, this.activeScopeId),
     };
@@ -143,6 +201,7 @@ export class BpmnStudioController {
   }
 
   setModel(model, { resetHistory = true } = {}) {
+    this._assertAllowedModel(model);
     const previousScopeId = this.activeScopeId;
     this._model = model;
     applyContainmentOperation(this._model, { type: 'reconcile' });
@@ -192,6 +251,7 @@ export class BpmnStudioController {
   }
 
   groupSelection() {
+    if (!this.allowsNodeType('group')) return null;
     const selected = selectedDiagramNodes(this._model, this.selection, this.activeScopeId);
     const groupable = selectedGroupableNodes(this._model, this.selection, this.activeScopeId);
     if (!groupable.length || groupable.length !== selected.length) return null;
@@ -303,6 +363,7 @@ export class BpmnStudioController {
   createNode({ nodeType, point, preset = {} } = {}) {
     const def = NODE_DEFINITIONS[nodeType];
     if (!def) throw new Error(`Unknown BPMN node type: ${nodeType}`);
+    if (!this.allowsNodeType(nodeType)) throw new Error(`BPMN node type is not allowed: ${nodeType}`);
     const position = point || { x: 100, y: 100 };
     let node;
     this._commit('create-node', () => {
@@ -331,9 +392,15 @@ export class BpmnStudioController {
     for (const spec of nodeSpecs) {
       if (!spec.key || keys.has(spec.key)) throw new Error('Template node keys must be unique.');
       if (!NODE_DEFINITIONS[spec.nodeType]) throw new Error(`Unknown BPMN node type: ${spec.nodeType}`);
+      if (!this.allowsNodeType(spec.nodeType)) throw new Error(`BPMN node type is not allowed: ${spec.nodeType}`);
       keys.add(spec.key);
     }
-    for (const edge of template.edges || []) if (!keys.has(edge.source) || !keys.has(edge.target)) throw new Error('Template edge references an unknown node key.');
+    for (const edge of template.edges || []) {
+      if (!keys.has(edge.source) || !keys.has(edge.target)) throw new Error('Template edge references an unknown node key.');
+      const edgeType = edge.preset?.type || 'sequenceFlow';
+      if (!EDGE_DEFINITIONS[edgeType]) throw new Error(`Unknown BPMN edge type: ${edgeType}`);
+      if (!this.allowsEdgeType(edgeType)) throw new Error(`BPMN edge type is not allowed: ${edgeType}`);
+    }
     const result = { nodes: [], edges: [] };
     const byKey = new Map();
     this._commit('create-template', () => {
@@ -355,6 +422,9 @@ export class BpmnStudioController {
   }
 
   connect(source, target, overrides = {}) {
+    const edgeType = overrides.type || 'sequenceFlow';
+    if (!EDGE_DEFINITIONS[edgeType]) throw new Error(`Unknown BPMN edge type: ${edgeType}`);
+    if (!this.allowsEdgeType(edgeType)) throw new Error(`BPMN edge type is not allowed: ${edgeType}`);
     if (!canCreateSequenceFlow(this._model, source, target)) return null;
     let edge;
     this._commit('connect', () => {
@@ -366,6 +436,7 @@ export class BpmnStudioController {
   }
 
   startConnect(sourceId) {
+    if (!this.allowsEdgeType('sequenceFlow')) return false;
     const source = getNode(this._model, sourceId);
     const definition = source && (NODE_DEFINITIONS[source.type] || NODE_DEFINITIONS.generic);
     if (!source || elementScopeId(this._model, source) !== this.activeScopeId || !SEQUENCE_FLOW_KINDS.has(definition.kind) || definition.eventStage === 'end') return false;
@@ -407,6 +478,9 @@ export class BpmnStudioController {
   updateNode(id, patch = {}) {
     const node = getNode(this._model, id);
     if (!node) return false;
+    if (patch.type !== undefined && patch.type !== node.type) {
+      throw new Error('Node type changes must use changeNodeType().');
+    }
     const previousLabelPlacement = resolveSwimlaneLabelPlacement(this._model, node);
     this._commit('update-node', () => {
       if (patch.properties) node.properties = { ...node.properties, ...patch.properties };
@@ -431,6 +505,9 @@ export class BpmnStudioController {
   updateEdge(id, patch = {}) {
     const edge = getEdge(this._model, id);
     if (!edge) return false;
+    if (patch.type !== undefined && patch.type !== (edge.type || 'sequenceFlow')) {
+      throw new Error('Edge type cannot be changed through updateEdge().');
+    }
     this._commit('update-edge', () => {
       if (patch.properties) edge.properties = { ...(edge.properties || {}), ...patch.properties };
       const rest = { ...patch }; delete rest.properties;
@@ -500,7 +577,7 @@ export class BpmnStudioController {
   changeNodeType(id, type) {
     const node = getNode(this._model, id);
     const def = NODE_DEFINITIONS[type];
-    if (!node || !def || node.type === type) return false;
+    if (!node || !def || !this.allowsNodeType(type) || node.type === type) return false;
     if (isEmbeddedSubProcess(node) && !isEmbeddedSubProcess(type) && hasScopeChildren(this._model, id)) return false;
     this._commit('change-node-type', () => {
       const next = createNode(type, node.x, node.y, { id: node.id, name: node.name });
@@ -514,9 +591,10 @@ export class BpmnStudioController {
   }
 
   quickAdd(sourceId, type = 'userTask', preset = {}) {
+    if (!this.allowsEdgeType('sequenceFlow')) return null;
     const source = getNode(this._model, sourceId);
     const def = NODE_DEFINITIONS[type];
-    if (!source || elementScopeId(this._model, source) !== this.activeScopeId || !def) return null;
+    if (!source || elementScopeId(this._model, source) !== this.activeScopeId || !def || !this.allowsNodeType(type)) return null;
     const direction = this._model.settings?.direction || 'horizontal';
     const spacing = LAYOUT_DENSITIES[this._model.settings?.layoutDensity || 'balanced'] || LAYOUT_DENSITIES.balanced;
     const outgoingCount = this._model.edges.filter((edge) => edge.source === sourceId).length;

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from './modules/palette/index.js'
 import type {
   BpmnEdge,
   BpmnNode,
+  EdgeType,
   ElementSelection,
   EngineId,
   LayoutOptions,
@@ -201,9 +202,16 @@ export interface StudioState {
   canRedo: boolean
   engine: EngineId
   propertiesProfile: 'business' | 'developer'
+  allowedNodeTypes: NodeType[] | null
+  allowedEdgeTypes: EdgeType[] | null
   activeScopeId: string
   scopePath: Array<{ id: string; name: string; kind: 'process' | 'subProcess' }>
 }
+export interface StudioValidationIssue {
+  level: 'error' | 'warning'
+  elementId?: string
+  message: string
+}
 export interface NodePreset extends Partial<Omit<BpmnNode, 'properties'>> { properties?: Record<string, unknown> }
 export interface TemplateDefinition {
   nodes: Array<{ key: string; nodeType: NodeType; offset?: Point; preset?: NodePreset }>
@@ -223,6 +231,8 @@ export interface StudioControllerOptions {
   historyLimit?: number
   extensions?: StudioExtension[]
   propertiesProfile?: 'business' | 'developer'
+  allowedNodeTypes?: Iterable<NodeType> | null
+  allowedEdgeTypes?: Iterable<EdgeType> | null
 }
 export interface StudioCommands {
   createNode(input: { nodeType: NodeType; point?: Point; preset?: NodePreset }): BpmnNode
@@ -289,6 +299,8 @@ export class BpmnStudioController {
   navigateToScope(scopeId: string): boolean
   setModel(model: ProcessModel, options?: { resetHistory?: boolean }): void
   setPropertiesProfile(profile: 'business' | 'developer'): void
+  allowsNodeType(nodeType: NodeType): boolean
+  allowsEdgeType(edgeType: EdgeType): boolean
   startConnect(sourceId: string): boolean
   cancelConnect(): void
   createNode(input: Parameters<StudioCommands['createNode']>[0]): BpmnNode
@@ -311,6 +323,7 @@ export class BpmnStudioController {
   redo(): boolean
   exportXml(engine?: EngineId): string
   importXml(xml: string, engine?: EngineId): ProcessModel
+  validate(): StudioValidationIssue[]
   registerExtension(extension: StudioExtension): () => void
   destroy(): void
 }
@@ -430,10 +443,38 @@ export class BpmnCanvas {
 }
 export function createBpmnCanvas(options: BpmnCanvasOptions): BpmnCanvas
 
+export interface StudioShellActions {
+  undo(): boolean
+  redo(): boolean
+  beautify(options?: LayoutOptions): void
+  rerouteEdges(options?: LayoutOptions): void
+  fitView(): void
+  validate(): StudioValidationIssue[]
+  importXml(xml: string, engine?: EngineId): ProcessModel
+  exportXml(engine?: EngineId): string
+  exportSvg(options?: SvgExportOptions): Promise<SvgExportArtifact>
+  openSvgExportPreview(options?: SvgExportOptions & {
+    previewTitle?: string
+    onDownload?: (artifact: SvgExportArtifact) => void
+  }): SvgExportPreviewController | null
+}
+export interface StudioShellSlotContext {
+  studio: BpmnStudioController
+  shell: BpmnStudioShell
+  canvas: BpmnCanvas
+  actions: StudioShellActions
+  getState(): StudioState
+  subscribe(listener: (event: StudioEvent) => void): () => void
+}
+export type StudioShellDomSlot =
+  | HTMLElement
+  | ((context: StudioShellSlotContext & { container: HTMLElement }) => void | (() => void))
 export interface StudioShellSlots {
-  left?: HTMLElement | ((context: Record<string, unknown>) => void | (() => void))
-  right?: HTMLElement | ((context: Record<string, unknown>) => void | (() => void))
-  header?: HTMLElement | ((context: Record<string, unknown>) => void | (() => void))
+  left?: StudioShellDomSlot
+  right?: StudioShellDomSlot
+  headerStart?: StudioShellDomSlot
+  header?: StudioShellDomSlot
+  footer?: StudioShellDomSlot
   contextMenu?: ContextMenuSlot
   selectionToolbar?: SelectionToolbarSlot
   runtimeDetails?: RuntimeDetailsRenderer
@@ -441,6 +482,19 @@ export interface StudioShellSlots {
   runtimeTimeline?: RuntimeTimelineRenderer
   [name: string]: HTMLElement | Function | undefined
 }
+export type StudioShellRegionMode = 'default' | 'hidden'
+export interface StudioShellRegions {
+  header?: StudioShellRegionMode
+  left?: StudioShellRegionMode
+  right?: StudioShellRegionMode
+  footer?: StudioShellRegionMode
+}
+export interface StudioShellRegionState {
+  header: StudioShellRegionMode
+  left: StudioShellRegionMode
+  right: StudioShellRegionMode
+  footer: StudioShellRegionMode
+}
 export interface StudioShellOptions {
   container: HTMLElement
   studio: BpmnStudioController
@@ -454,9 +508,11 @@ export interface StudioShellOptions {
     timeline?: ViewerTimelineOptions
   }
   slots?: StudioShellSlots
+  regions?: StudioShellRegions
   layout?: (context: Record<string, unknown>) => void | (() => void)
   runtime?: ProcessInstanceSnapshot | null
   mode?: 'design' | 'viewer' | 'instance'
+  allowedModes?: Array<'design' | 'viewer' | 'instance'>
   projection?: ViewerProjection
   responsive?: boolean
   projectionOptions?: Array<{ value: ViewerProjection; label: string }>
@@ -469,8 +525,11 @@ export interface StudioShellOptions {
 }
 export class BpmnStudioShell {
   constructor(options: StudioShellOptions)
+  readonly actions: StudioShellActions
   canvas?: BpmnCanvas
   viewer?: BpmnViewer
+  getRegions(): Readonly<StudioShellRegionState>
+  setRegions(regions: StudioShellRegions): Readonly<StudioShellRegionState>
   setMode(mode: 'design' | 'viewer' | 'instance'): void
   setRuntime(runtime: ProcessInstanceSnapshot | null): void
   setProjection(projection: ViewerProjection): void

package/dist/modules/palette/index.d.ts

@@ -39,6 +39,18 @@ export const defaultBpmnPaletteProvider: PaletteProvider
 export function createPaletteRegistry(): PaletteRegistry
 export function createDefaultPaletteRegistry(options?: { providers?: PaletteProvider[] }): PaletteRegistry
 
+export type PaletteItemRenderer = (context: {
+  container: HTMLElement
+  item: PaletteItem
+  panel: PalettePanel
+  beginCreate(): unknown
+}) => void | (() => void)
+export type PaletteSectionRenderer = (context: {
+  container: HTMLElement
+  section: PaletteSection
+  panel: PalettePanel
+}) => void | (() => void)
+
 export interface PalettePanelOptions {
   container: HTMLElement
   registry: PaletteRegistry
@@ -46,8 +58,8 @@ export interface PalettePanelOptions {
   interactions: { beginCreate(intent: PaletteCreateIntent): unknown; serialize(session: unknown): string }
   canvas?: unknown
   iconRegistry?: IconRegistry
-  renderItem?: ((context: { item: PaletteItem; panel: PalettePanel }) => HTMLElement | null) | null
-  renderSection?: ((context: { section: PaletteSection; panel: PalettePanel }) => HTMLElement | null) | null
+  renderItem?: PaletteItemRenderer | null
+  renderSection?: PaletteSectionRenderer | null
   themeController?: ThemeController | null
   theme?: NovaThemeInput | null
   onThemeChange?: ((state: NovaThemeState) => void) | null

package/dist/modules/palette/index.js

@@ -56,10 +56,10 @@ export class PaletteRegistry {
 export const defaultBpmnPaletteProvider = {
   id: 'bpmn-default-palette',
   priority: 100,
-  getSections() {
+  getSections(context = {}) {
     return PALETTE_GROUPS.map((group) => {
       const items = [];
-      for (const nodeType of group.types) {
+      for (const nodeType of group.types.filter((type) => context.studio?.allowsNodeType?.(type) !== false)) {
         if (nodeType === 'parallelGateway') {
           items.push({
             id: 'node-parallelGateway',
@@ -85,7 +85,7 @@ export const defaultBpmnPaletteProvider = {
         });
       }
       return { id: group.id, label: group.label, collapsed: group.id !== 'favorites', items };
-    });
+    }).filter((section) => section.items.length);
   },
 };
 

package/dist/modules/properties-bpmn/index.js

@@ -17,7 +17,9 @@ function nodeTypeOptions(context) {
       ? ['task', 'container']
       : [currentKind];
   return Object.entries(NODE_DEFINITIONS)
-    .filter(([type, def]) => type !== 'generic' && compatible.includes(def.kind))
+    .filter(([type, def]) => type !== 'generic'
+      && compatible.includes(def.kind)
+      && context.studio?.allowsNodeType?.(type) !== false)
     .map(([value, def]) => ({ value, label: def.label }));
 }
 

package/dist/modules/renderer-svg/index.d.ts

@@ -84,6 +84,7 @@ export interface DiagramRendererOptions {
   onEdgeClick?: (edge: BpmnEdge, event: Event) => void
   onCanvasClick?: (event: Event) => void
   onViewportChange?: (state: { zoom: number; pan: Point }) => void
+  canCreateNodeType?: (nodeType: string) => boolean
   [key: string]: unknown
 }
 export class DiagramRenderer {

package/dist/modules/renderer-svg/index.js

@@ -1424,7 +1424,7 @@ export class DiagramRenderer {
         const type = quickItem.nodeType;
         if (type === 'startEvent') continue;
         const def = NODE_DEFINITIONS[type];
-        if (!def) continue;
+        if (!def || this.options.canCreateNodeType?.(type) === false) continue;
         const item = el('button', 'mb-quick-menu-item');
         item.dataset.search = `${quickItem.id} ${type} ${quickItem.label}`.toLowerCase();
         const miniIcon = el('span', `mb-mini-type mb-mini-kind-${def.kind}`);