bazis 0.133.0 → 0.135.0

package/core/workflow/contracts/WorkflowPartitions.ts

@@ -0,0 +1,29 @@
+import type { WorkflowPortContext } from "./WorkflowExtensions";
+
+/** A partition a process is connected to. */
+export interface ProcessPartition {
+  /** `null`: the process runs without a partition. */
+  readonly partition: string | null;
+  /** An IANA time zone for the schedules of this partition; a time zone on the node goes first. */
+  readonly timezone?: string;
+  /** A process that is switched off here takes no events and no scheduled starts. */
+  readonly enabled: boolean;
+}
+
+/**
+ * Where a process works (WORKFLOW-002 §6): tenants, spaces, organizations. An
+ * event starts a process only in a partition listed here, a schedule with
+ * `partitions: "all"` runs in every enabled one, and a process connected to a
+ * partition cannot be deleted. The application registers its implementation in
+ * any module.
+ */
+export abstract class WorkflowPartitions {
+  abstract of(processKey: string, context: WorkflowPortContext): readonly ProcessPartition[] | Promise<readonly ProcessPartition[]>;
+}
+
+/** By default a process has one place to work: no partition. */
+export class DefaultWorkflowPartitions extends WorkflowPartitions {
+  of(): readonly ProcessPartition[] {
+    return [{ partition: null, enabled: true }];
+  }
+}

package/core/workflow/contracts/WorkflowProcessUsage.ts

@@ -0,0 +1,8 @@
+/**
+ * What the catalog asks before it deletes a process. Runtime answers: the catalog
+ * knows nothing of instances, and without Runtime there are none.
+ */
+export abstract class WorkflowProcessUsage {
+  /** How many `pending`, `running` and `failed` instances the process has. */
+  abstract liveInstances(processKey: string): Promise<number>;
+}

package/core/workflow/definitions_module/WorkflowDefinitions.module.ts

@@ -3,13 +3,16 @@ import { HOSTED_SERVICE, Module, scoped, singleton } from "../../di";
 import { SystemWorkflowClock, WorkflowClock } from "../contracts/WorkflowClock";
 import { workflowConfig } from "../contracts/Workflow.config";
 import { DefaultWorkflowExtensions, WorkflowExtensions } from "../contracts/WorkflowExtensions";
+import { DefaultWorkflowPartitions, WorkflowPartitions } from "../contracts/WorkflowPartitions";
 import { WorkflowEvents } from "../internal/WorkflowEvents";
 import { WorkflowLanguages } from "../internal/WorkflowLanguages";
+import { WorkflowReferences } from "../internal/WorkflowReferences";
 import { WorkflowTools } from "../internal/WorkflowTools";
 import { definitionsPermissions } from "./access/Definitions.permissions";
 import { FolderReferences } from "./access/Folder.references";
 import { ProcessReferences } from "./access/Process.references";
 import { ProcessFolderLookup } from "./access/ProcessFolder.lookup";
+import { ProcessPartitionLookup } from "./access/ProcessPartition.lookup";
 import { CatalogImport } from "./code/CatalogImport";
 import { CodeProcessCatalog } from "./code/CodeProcessCatalog";
 import { CodeProcessPublisher } from "./code/CodeProcessPublisher";
@@ -23,7 +26,8 @@ import { WorkflowDefinitions } from "./services/WorkflowDefinitions.service";
 /**
  * The process catalog: drafts and published versions, and the processes
  * declared in code ([passport](MODULE.md)). The application checks its own
- * `extensions` by registering its `WorkflowExtensions`.
+ * `extensions` by registering its `WorkflowExtensions` and says where processes
+ * work by registering its `WorkflowPartitions`.
  */
 @Module({
   imports: [AccessModule],
@@ -37,15 +41,18 @@ import { WorkflowDefinitions } from "./services/WorkflowDefinitions.service";
     singleton(CodeProcessCatalog),
     singleton(WorkflowLanguages),
     singleton(WorkflowExtensions, DefaultWorkflowExtensions),
+    singleton(WorkflowPartitions, DefaultWorkflowPartitions),
     scoped(WorkflowEvents),
+    scoped(WorkflowReferences),
     scoped(CatalogImport),
     scoped(IWorkflowDefinitions, WorkflowDefinitions),
     scoped(ProcessReferences),
     scoped(FolderReferences),
     scoped(ProcessFolderLookup),
+    scoped(ProcessPartitionLookup),
     singleton(HOSTED_SERVICE, CodeProcessPublisher),
   ],
   controllers: [ProcessesController],
-  exports: [IWorkflowDefinitions, WorkflowTools, WorkflowClock, WorkflowEvents, WorkflowLanguages, WorkflowExtensions, ProcessFolderLookup],
+  exports: [IWorkflowDefinitions, WorkflowReferences, WorkflowTools, WorkflowClock, WorkflowEvents, WorkflowLanguages, WorkflowExtensions, WorkflowPartitions, ProcessFolderLookup],
 })
 export class WorkflowDefinitionsModule {}

package/core/workflow/definitions_module/access/Definitions.permissions.ts

@@ -1,16 +1,18 @@
 import { definePermissions } from "../../../access";
+import { ProcessPartitionLookup } from "./ProcessPartition.lookup";
 
 const process = { ref: "workflow.process", column: "key" };
 const folder = { ref: "workflow.folder", column: "folder" };
 
 /**
  * The rights of the process catalog (WORKFLOW-002 §6.2). A process is one per
- * application, so these have no partition until `WorkflowPartitions` connects
- * processes to partitions (stage 4).
+ * application: only reading it has partitions, those `WorkflowPartitions`
+ * connects it to.
  */
 export const definitionsPermissions = definePermissions({
   "workflow.processes.read": {
     title: { en: "See processes", ru: "Видеть процессы" },
+    scope: { lookup: ProcessPartitionLookup },
     on: { process, folder },
   },
   "workflow.processes.manage": {

package/core/workflow/definitions_module/access/ProcessPartition.lookup.ts

@@ -0,0 +1,27 @@
+import { AttributeLookup, type AccessValue, type LookupColumn } from "../../../access";
+import type { ServiceProvider } from "../../../di";
+import { WorkflowPartitions } from "../../contracts/WorkflowPartitions";
+import type { WorkflowLanguages } from "../../internal/WorkflowLanguages";
+import type { DefinitionsDbContext } from "../model/Definitions.dbContext";
+
+/** The partitions of a process are not a column: partition → the keys of the processes connected to it (WORKFLOW-002 §6.2). */
+export class ProcessPartitionLookup extends AttributeLookup {
+  constructor(
+    private readonly db: DefinitionsDbContext,
+    private readonly languages: WorkflowLanguages,
+    private readonly services: ServiceProvider,
+  ) {
+    super();
+  }
+
+  async toColumn(values: readonly AccessValue[]): Promise<LookupColumn> {
+    const port = this.services.resolve(WorkflowPartitions);
+    const rows = await this.db.processes.asNoTracking().select((p) => ({ key: p.key })).toList();
+    const keys: string[] = [];
+    for (const { key } of rows) {
+      const partitions = await port.of(key, { partition: null, language: this.languages.default, actor: null });
+      if (partitions.some((item) => item.enabled && values.includes(item.partition))) keys.push(key);
+    }
+    return { column: "key", in: keys };
+  }
+}

package/core/workflow/definitions_module/code/CodeProcessPublisher.ts

@@ -1,6 +1,7 @@
 import { markConfigurationError, type ServiceProvider } from "../../../di";
 import type { HostedService } from "../../../di/extensions/hosted-service";
 import { LOGGER } from "../../../kernel";
+import { WorkflowReferences } from "../../internal/WorkflowReferences";
 import { WorkflowTools } from "../../internal/WorkflowTools";
 import { IWorkflowDefinitions } from "../services/IWorkflowDefinitions.service";
 import { CatalogImport } from "./CatalogImport";
@@ -12,7 +13,9 @@ import { definitionProblems, WorkflowSetupError } from "./codeProcesses";
  * (WORKFLOW-002 §9), then publishes the processes of `@Module({ processes })`
  * (WORKFLOW-001 §14). A document with an unknown Tool or process, or an `extensions`
  * namespace nobody checks, stops the start with every finding of every process; the same
- * document again gives no new version.
+ * document again gives no new version. So does a reference kind no module owns, in a Tool
+ * or a document. A value that does not exist only warns: it may be data that is yet to come,
+ * and the step then fails with `ref_not_found`.
  */
 export class CodeProcessPublisher implements HostedService {
   readonly diagnosticName = "workflow:processes";
@@ -25,6 +28,11 @@ export class CodeProcessPublisher implements HostedService {
     try {
       const imported = await scope.resolve(CatalogImport).run();
       if (imported > 0) logger?.info("workflow catalog brought over from the old store", { processes: imported });
+      const references = scope.resolve(WorkflowReferences);
+      const unowned = references.unownedToolKinds();
+      if (unowned.length > 0) {
+        throw markConfigurationError(new WorkflowSetupError(`Tools refer to kinds no module owns:\n${unowned.map(({ tool, kind }) => `  - ${tool}: ${kind}${kind.startsWith("orm.") ? " (import StandardToolsModule from bazis/core/tools)" : " (declare it in @Module({ references }))"}`).join("\n")}`));
+      }
       const entries = this.services.resolve(CodeProcessCatalog).list();
       if (entries.length === 0) return;
       const tools = this.services.resolve(WorkflowTools);
@@ -35,6 +43,10 @@ export class CodeProcessPublisher implements HostedService {
         const found = [...definitionProblems(process, (name) => tools.has(name))];
         for (const issue of await definitions.validate(process.document, { processes })) {
           if (issue.severity === "error" && (issue.code === "extension_unknown" || issue.code === "extension_invalid" || issue.code === "unknown_process")) found.push(`${issue.message} (${issue.code})`);
+          else if (issue.code === "broken_ref") {
+            if (issue.message.startsWith("no module owns")) found.push(`${issue.message} (${issue.code})`);
+            else logger?.warn("workflow process refers to what does not exist", { process: process.key, node: issue.node, message: issue.message });
+          }
         }
         if (found.length > 0) problems.push(`${module}: process "${process.key}":\n${found.map((line) => `  - ${line}`).join("\n")}`);
       }

package/core/workflow/definitions_module/code/inspectProcesses.ts

@@ -1,6 +1,6 @@
 import { expandModuleMetadata, type BazisModuleRef } from "../../../di";
-import { toolMetadataOf } from "../../../agent";
-import { validateProcess } from "../../../../library/workflow";
+import { describeTool, toolMetadataOf } from "../../../agent";
+import { documentReferences, schemaReferenceKinds, validateProcess } from "../../../../library/workflow";
 import { WORKFLOW_CALLER } from "../../internal/WorkflowTools";
 import { WorkflowDefinitionsModule } from "../WorkflowDefinitions.module";
 import { definitionProblems, type OwnedCodeProcess } from "./codeProcesses";
@@ -28,16 +28,23 @@ export function inspectProcesses(root: BazisModuleRef): ProcessInspection {
   const found: OwnedCodeProcess[] = [];
   const errors: string[] = [];
   const tools = new Set<string>();
+  const schemas = new Map<string, unknown>();
+  const kinds = new Set<string>();
   const visited = new Set<BazisModuleRef>();
   const visit = (moduleRef: BazisModuleRef): void => {
     if (visited.has(moduleRef)) return;
     visited.add(moduleRef);
     const module = typeof moduleRef === "function" ? moduleRef.name || "<anonymous module>" : "<module>";
-    const fields = moduleRef as { readonly processes?: unknown; readonly tools?: unknown };
+    const fields = moduleRef as { readonly processes?: unknown; readonly tools?: unknown; readonly references?: unknown };
+    if (typeof fields.references === "object" && fields.references !== null) for (const kind of Object.keys(fields.references)) kinds.add(kind);
     if (Array.isArray(fields.tools)) {
       for (const target of fields.tools) {
         const metadata = typeof target === "function" ? toolMetadataOf(target as new () => object) : undefined;
-        if (metadata?.callers.includes(WORKFLOW_CALLER)) tools.add(metadata.name);
+        if (metadata?.callers.includes(WORKFLOW_CALLER)) {
+          tools.add(metadata.name);
+          const input = describeTool({ target: target as new () => object, metadata }).input;
+          if (input?.kind === "json-schema") schemas.set(metadata.name, input.schema);
+        }
       }
     }
     if (fields.processes !== undefined) {
@@ -54,6 +61,10 @@ export function inspectProcesses(root: BazisModuleRef): ProcessInspection {
   if (found.length > 0 && !visited.has(WorkflowDefinitionsModule)) {
     errors.push(`${found[0]!.module} declares processes, but the application does not import WorkflowModule (bazis/core/workflow).`);
   }
+  // The values live in the database: `check` knows only whether someone owns their kind.
+  for (const [tool, schema] of schemas) {
+    for (const kind of schemaReferenceKinds(schema)) if (!kinds.has(kind)) errors.push(`Tool ${tool} refers to the kind ${kind}, and no module owns it.`);
+  }
   const owners = new Map<string, string>();
   for (const { process, module } of found) {
     const other = owners.get(process.key);

package/core/workflow/definitions_module/events/Definitions.events.ts

@@ -1,7 +1,7 @@
 import { createEventToken } from "../../../kernel";
 import type { WorkflowActor, WorkflowRequest } from "../../contracts/types";
 
-export type ProcessChange = "created" | "updated" | "draftSaved" | "published" | "archived" | "restored";
+export type ProcessChange = "created" | "updated" | "draftSaved" | "published" | "archived" | "restored" | "deleted";
 
 /** A process of the catalog changed, for the application's audit. Published after the commit. */
 export interface WorkflowProcessChanged {

package/core/workflow/definitions_module/http/Processes.controller.ts

@@ -1,7 +1,7 @@
 import { contextOnlyController } from "../../../http/Routing/contextOnlyControllers";
 import { can, type AccessObject } from "../../../access";
 import type { LocalizedText } from "../../../../library/workflow";
-import { Authorize, Controller, Created, Get, Patch, Post, Put, type HttpContext } from "../../../http";
+import { Authorize, Controller, Created, Delete, Get, Patch, Post, Put, type HttpContext } from "../../../http";
 import { buildListDocument } from "../../../../library/jsonapi";
 import { body, callerOf, defaultLanguage, filterOf, listQuery, optionalInteger, optionalString, optionalText, pagingOfList, param, requiredString, withTitleText } from "../../internal/http";
 import { WorkflowError } from "../../contracts/WorkflowError";
@@ -52,10 +52,20 @@ export class ProcessesController {
   @Authorize(can("workflow.processes.read"))
   async get(ctx: HttpContext) {
     const key = param(ctx, "key");
-    const { language } = await callerOf(ctx, "workflow.processes.read", await this.objectOf(key));
+    const { language } = await callerOf(ctx, "workflow.processes.read", await this.readObjectOf(key));
     return withTitleText(await this.definitions.get(key), language, defaultLanguage(ctx));
   }
 
+  /** An archived process without unfinished instances and partitions (WORKFLOW-002 §4.3). */
+  @Delete("processes/:key")
+  @Authorize(can("workflow.processes.manage"))
+  async remove(ctx: HttpContext) {
+    const key = param(ctx, "key");
+    const { actor, request } = await callerOf(ctx, "workflow.processes.manage", await this.objectOf(key));
+    await this.definitions.remove(key, actor, { request });
+    ctx.res.status(204);
+  }
+
   @Patch("processes/:key")
   @Authorize(can("workflow.processes.manage"))
   async update(ctx: HttpContext) {
@@ -102,7 +112,7 @@ export class ProcessesController {
   @Authorize(can("workflow.processes.read"))
   async versions(ctx: HttpContext) {
     const key = param(ctx, "key");
-    await callerOf(ctx, "workflow.processes.read", await this.objectOf(key));
+    await callerOf(ctx, "workflow.processes.read", await this.readObjectOf(key));
     return { data: await this.definitions.versions(key) };
   }
 
@@ -110,7 +120,7 @@ export class ProcessesController {
   @Authorize(can("workflow.processes.read"))
   async version(ctx: HttpContext) {
     const key = param(ctx, "key");
-    await callerOf(ctx, "workflow.processes.read", await this.objectOf(key));
+    await callerOf(ctx, "workflow.processes.read", await this.readObjectOf(key));
     const version = optionalInteger(param(ctx, "version"), "version");
     if (version === undefined) throw new WorkflowError("invalid_input", "version must be an integer");
     return await this.definitions.version(key, version);
@@ -144,6 +154,11 @@ export class ProcessesController {
     return { process: key, folder: await this.definitions.folderOf(key) };
   }
 
+  /** Reading a process is allowed by the partitions it works in. */
+  private async readObjectOf(key: string): Promise<AccessObject> {
+    return { ...await this.objectOf(key), scope: await this.definitions.partitionsOf(key) };
+  }
+
   private localized(items: readonly ProcessSummary[], language: string, ctx: HttpContext) {
     return items.map((item) => withTitleText(item, language, defaultLanguage(ctx)));
   }

package/core/workflow/definitions_module/services/IWorkflowDefinitions.service.ts

@@ -92,6 +92,24 @@ export interface SavedDraft {
   readonly draftUpdatedAt: Date;
 }
 
+export interface ProcessReferenceQuery {
+  readonly kind: string;
+  readonly id: string;
+  /** The area of the value: the table of a field. Without it any area goes. */
+  readonly within?: string;
+}
+
+/** A process that refers to a value, and where. */
+export interface ProcessReference {
+  readonly processKey: string;
+  readonly version: number;
+  readonly node?: string;
+  readonly variable?: string;
+  readonly within?: string;
+  /** Where in the input of the step: `/values/status`. */
+  readonly path: string;
+}
+
 /**
  * The process catalog: drafts and immutable published versions
  * (WORKFLOW-001 §3). Errors are {@link WorkflowError}: `not_found`, `conflict`,
@@ -102,6 +120,8 @@ export abstract class IWorkflowDefinitions {
   abstract get(key: string): Promise<ProcessDetails>;
   /** The folder of a process, for a check of rights; `null` also for a process that does not exist. */
   abstract folderOf(key: string): Promise<string | null>;
+  /** The partitions a process works in, for a check of rights. */
+  abstract partitionsOf(key: string): Promise<readonly (string | null)[]>;
   /** Every finding of a document, with the application's `extensions` checks; nothing is stored. */
   abstract validate(document: unknown, options?: ValidateOptions): Promise<readonly ProcessIssue[]>;
   /** What a designer builds its forms from: node kinds, functions, paths and Tools. */
@@ -109,6 +129,12 @@ export abstract class IWorkflowDefinitions {
   abstract create(process: CreateProcess, actor: WorkflowActor, options?: WorkflowAuditOptions): Promise<ProcessDetails>;
   /** A process declared in code takes only `archived`; other fields give `conflict`. */
   abstract update(key: string, changes: UpdateProcess, actor: WorkflowActor, options?: WorkflowAuditOptions): Promise<ProcessDetails>;
+  /**
+   * Deletes an archived process with its versions: `wrong_status` when it is not
+   * archived, `conflict` when it is declared in code, `in_use` when it has unfinished
+   * instances or partitions. Finished instances and their history stay.
+   */
+  abstract remove(key: string, actor: WorkflowActor, options?: WorkflowAuditOptions): Promise<void>;
   /** Stores the draft even with errors; `conflict` for a process declared in code and when `expected` is out of date. */
   abstract saveDraft(key: string, document: unknown, actor: WorkflowActor, options?: SaveDraftOptions): Promise<SavedDraft>;
   /**
@@ -124,6 +150,11 @@ export abstract class IWorkflowDefinitions {
   abstract published(): Promise<readonly VersionDetails[]>;
   /** A version by id, for the engine; `undefined` if there is none. */
   abstract versionById(id: string): Promise<VersionDetails | undefined>;
+  /**
+   * Who refers to a value (WORKFLOW-002 §6.3), by the latest published versions: the
+   * application forbids or warns before it removes a field or a table.
+   */
+  abstract referencing(reference: ProcessReferenceQuery): Promise<readonly ProcessReference[]>;
   /** Processes with a retention period: what the retention service deletes. */
   abstract retentionPolicies(): Promise<readonly { readonly key: string; readonly retentionDays: number }[]>;
   /** The Tools a service task may call, with their input and output schemas. */

package/core/workflow/definitions_module/services/WorkflowDefinitions.service.ts

@@ -2,15 +2,18 @@ import { grantsToWhere } from "../../../access";
 import { createHash } from "node:crypto";
 import { paginate, UniqueViolationError } from "../../../orm";
 import type { AgentToolContract } from "../../../agent";
-import { allTexts, checkLocalizedText, emptyProcess, hasErrors, processPalette, validateProcess, type LocalizedText, type ProcessDocument, type ProcessIssue, type ProcessPalette } from "../../../../library/workflow";
+import { allTexts, checkLocalizedText, emptyProcess, hasErrors, processPalette, validateProcess, type DocumentReference, type LocalizedText, type ProcessDocument, type ProcessIssue, type ProcessPalette } from "../../../../library/workflow";
 import type { ServiceProvider } from "../../../di";
 import { isUuid, pageQueryOf, type WorkflowActor, type WorkflowAuditOptions, type WorkflowPage } from "../../contracts/types";
 import type { WorkflowClock } from "../../contracts/WorkflowClock";
 import { WorkflowError } from "../../contracts/WorkflowError";
 import { WorkflowExtensions, type ExtensionTarget, type WorkflowPortContext } from "../../contracts/WorkflowExtensions";
+import { WorkflowPartitions } from "../../contracts/WorkflowPartitions";
+import { WorkflowProcessUsage } from "../../contracts/WorkflowProcessUsage";
 import { canonicalJson } from "../../internal/canonicalJson";
 import type { WorkflowEvents } from "../../internal/WorkflowEvents";
 import type { WorkflowLanguages } from "../../internal/WorkflowLanguages";
+import type { WorkflowReferences } from "../../internal/WorkflowReferences";
 import type { WorkflowTools } from "../../internal/WorkflowTools";
 import type { CodeProcessCatalog } from "../code/CodeProcessCatalog";
 import type { OwnedCodeProcess } from "../code/codeProcesses";
@@ -23,6 +26,8 @@ import {
   type CreateProcess,
   type ProcessDetails,
   type ProcessListQuery,
+  type ProcessReference,
+  type ProcessReferenceQuery,
   type ProcessSummary,
   type SavedDraft,
   type SaveDraftOptions,
@@ -46,6 +51,7 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
     private readonly clock: WorkflowClock,
     private readonly events: WorkflowEvents,
     private readonly languages: WorkflowLanguages,
+    private readonly references: WorkflowReferences,
     /** The scope: the port is asked here, so that the application's own registration replaces the default. */
     private readonly services: ServiceProvider,
   ) {
@@ -83,13 +89,22 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
     return row?.folder ?? null;
   }
 
+  async partitionsOf(key: string): Promise<readonly (string | null)[]> {
+    const partitions = await this.partitions(key, null);
+    return partitions.filter((item) => item.enabled).map((item) => item.partition);
+  }
+
+  private async partitions(key: string, actor: WorkflowActor | null) {
+    return await this.services.resolve(WorkflowPartitions).of(key, { partition: null, language: this.languages.default, actor });
+  }
+
   async validate(document: unknown, options: ValidateOptions = {}): Promise<readonly ProcessIssue[]> {
     const port = this.services.resolve(WorkflowExtensions);
     const namespaces = new Set(port.namespaces());
     const published = await this.db.processes.asNoTracking().where((p) => p.archivedAt.isNull().and(p.latestVersion.isNotNull())).select((p) => ({ key: p.key })).toList();
     const processes = new Set([...published.map((row) => row.key), ...options.processes ?? []]);
     const issues = validateProcess(document, { tools: (name) => this.workflowTools.has(name), processes: (key) => processes.has(key), extensions: (namespace) => namespaces.has(namespace) });
-    if (namespaces.size === 0 || issues.some((issue) => issue.code === "too_large" || issue.code === "schema")) return issues;
+    if (issues.some((issue) => issue.code === "too_large" || issue.code === "schema")) return issues;
     const context: WorkflowPortContext = { partition: null, language: options.language ?? this.languages.default, actor: options.actor ?? null };
     const found: ProcessIssue[] = [...issues];
     const { extensions, variables, nodes } = document as ProcessDocument;
@@ -100,9 +115,52 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
         for (const message of await port.check(namespace, value, target, context)) found.push({ severity: "error", code: "extension_invalid", message: `${namespace}: ${message}`, ...target });
       }
     };
-    await checkAll(extensions, {});
-    if (Array.isArray(variables)) for (const variable of variables) await checkAll(variable?.extensions, { variable: variable?.name });
-    for (const [node, raw] of Object.entries(nodes)) await checkAll(raw?.extensions, { node });
+    if (namespaces.size > 0) {
+      await checkAll(extensions, {});
+      if (Array.isArray(variables)) for (const variable of variables) await checkAll(variable?.extensions, { variable: variable?.name });
+      for (const [node, raw] of Object.entries(nodes)) await checkAll(raw?.extensions, { node });
+    }
+    found.push(...await this.brokenReferences(document as ProcessDocument, context.language));
+    return found;
+  }
+
+  /** The literal references no owner knows. The processes a document calls are told above as `unknown_process`. */
+  private async brokenReferences(document: ProcessDocument, language: string): Promise<ProcessIssue[]> {
+    let references: DocumentReference[];
+    try {
+      references = this.references.of(document);
+    } catch {
+      // A document that is not whole yet: its shape has been told above.
+      return [];
+    }
+    const missing = await this.references.missing(references.filter((reference) => reference.kind !== "workflow.process"), { scope: null, language });
+    return missing.map((reference) => ({
+      severity: "error" as const,
+      code: "broken_ref" as const,
+      message: this.references.owned(reference.kind)
+        ? `${reference.kind} ${JSON.stringify(reference.id)}${reference.within === undefined ? "" : ` in ${reference.within}`} does not exist`
+        : `no module owns the reference kind ${reference.kind}`,
+      ...(reference.node === undefined ? {} : { node: reference.node }),
+      ...(reference.variable === undefined ? {} : { variable: reference.variable }),
+    }));
+  }
+
+  async referencing(reference: ProcessReferenceQuery): Promise<readonly ProcessReference[]> {
+    const found: ProcessReference[] = [];
+    for (const version of await this.published()) {
+      for (const item of this.references.of(version.document)) {
+        if (item.kind !== reference.kind || item.id !== reference.id) continue;
+        if (reference.within !== undefined && item.within !== reference.within) continue;
+        found.push({
+          processKey: version.key,
+          version: version.version,
+          path: item.path,
+          ...(item.node === undefined ? {} : { node: item.node }),
+          ...(item.variable === undefined ? {} : { variable: item.variable }),
+          ...(item.within === undefined ? {} : { within: item.within }),
+        });
+      }
+    }
     return found;
   }
 
@@ -153,6 +211,19 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
     return this.detailsOf(row);
   }
 
+  async remove(key: string, actor: WorkflowActor, options: WorkflowAuditOptions = {}): Promise<void> {
+    const row = await this.process(key, false);
+    this.assertNotCode(key);
+    if (row.archivedAt === null) throw new WorkflowError("wrong_status", `Process ${key} is not archived`);
+    // An archived process starts nothing more, so what is counted here cannot grow.
+    const connected = (await this.partitions(key, actor)).filter((item) => item.partition !== null).map((item) => item.partition);
+    if (connected.length > 0) throw new WorkflowError("in_use", `Process ${key} is connected to partitions: ${connected.join(", ")}`);
+    const live = await this.services.tryResolve(WorkflowProcessUsage)?.liveInstances(key) ?? 0;
+    if (live > 0) throw new WorkflowError("in_use", `Process ${key} has ${live} unfinished instances`);
+    await this.db.processes.asNoTracking().where((p) => p.key.eq(key)).executeDelete();
+    await this.changed("deleted", key, actor, options);
+  }
+
   async saveDraft(key: string, document: unknown, actor: WorkflowActor, options: SaveDraftOptions = {}): Promise<SavedDraft> {
     const issues = await this.validate(document, { actor, ...(options.language === undefined ? {} : { language: options.language }) });
     if (issues.some((issue) => issue.code === "too_large")) throw new WorkflowError("invalid_document", "The document is too large", issues);
@@ -175,12 +246,15 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
   }
 
   async publish(key: string, actor: WorkflowActor, options: WorkflowAuditOptions & Pick<ValidateOptions, "language"> = {}): Promise<VersionDetails> {
+    // Before the transaction: the owners of references and the ports read their own contexts.
+    const draft = await this.process(key, false);
+    const issues = await this.validate(draft.draft, { actor, processes: [key], ...(options.language === undefined ? {} : { language: options.language }) });
     return await this.db.transactionScope(async (transaction) => {
       const row = await this.db.processes.where((p) => p.key.eq(key)).forUpdate().firstOrDefault();
       if (!row) throw notFound(key);
       this.assertNotCode(key);
       if (row.archivedAt !== null) throw new WorkflowError("archived", `Process ${key} is archived`);
-      const issues = await this.validate(row.draft, { actor, processes: [key], ...(options.language === undefined ? {} : { language: options.language }) });
+      if (canonicalJson(row.draft) !== canonicalJson(draft.draft)) throw new WorkflowError("conflict", `The draft of ${key} was saved while it was being published`);
       if (hasErrors(issues)) throw new WorkflowError("invalid_document", `Process ${key} has errors and cannot be published`, issues);
       const { version, created } = await this.publishDraft(row, actor);
       if (created) transaction.afterCommit(() => this.changed("published", key, actor, options, version.version));

package/core/workflow/generated/deps.ts

@@ -2,12 +2,14 @@
 // Do not edit manually.
 import { registerFrameworkClassDeps } from "../../di/module/autoDeps";
 import { DbContextOptions } from "../../../library/orm/DbContextOptions";
+import { IAccessCatalog } from "../../access/catalog/IAccessCatalog.service";
 import { ServiceProvider } from "../../di/ServiceProvider";
 import { EventBus } from "../../kernel/events/EventBus";
 import { WorkflowClock } from "../contracts/WorkflowClock";
 import { FolderReferences } from "../definitions_module/access/Folder.references";
 import { ProcessReferences } from "../definitions_module/access/Process.references";
 import { ProcessFolderLookup } from "../definitions_module/access/ProcessFolder.lookup";
+import { ProcessPartitionLookup } from "../definitions_module/access/ProcessPartition.lookup";
 import { CatalogImport } from "../definitions_module/code/CatalogImport";
 import { CodeProcessCatalog } from "../definitions_module/code/CodeProcessCatalog";
 import { CodeProcessPublisher } from "../definitions_module/code/CodeProcessPublisher";
@@ -17,14 +19,17 @@ import { IWorkflowDefinitions } from "../definitions_module/services/IWorkflowDe
 import { WorkflowDefinitions } from "../definitions_module/services/WorkflowDefinitions.service";
 import { WorkflowEvents } from "../internal/WorkflowEvents";
 import { WorkflowLanguages } from "../internal/WorkflowLanguages";
+import { WorkflowReferences } from "../internal/WorkflowReferences";
 import { WorkflowTools } from "../internal/WorkflowTools";
 import { WorkflowRetention } from "../runtime_module/background/WorkflowRetention";
 import { WorkflowWorker } from "../runtime_module/background/WorkflowWorker";
 import { EventsController } from "../runtime_module/http/Events.controller";
 import { InstancesController } from "../runtime_module/http/Instances.controller";
 import { ChildCalls } from "../runtime_module/internal/ChildCalls";
+import { EventDelivery } from "../runtime_module/internal/EventDelivery";
 import { GraphCache } from "../runtime_module/internal/GraphCache";
 import { RunLimits } from "../runtime_module/internal/RunLimits";
+import { RuntimeProcessUsage } from "../runtime_module/internal/RuntimeProcessUsage";
 import { Schedules } from "../runtime_module/internal/Schedules";
 import { TimerStep } from "../runtime_module/internal/TimerStep";
 import { ToolStep } from "../runtime_module/internal/ToolStep";
@@ -44,26 +49,30 @@ registerFrameworkClassDeps([
   [CodeProcessCatalog, [ServiceProvider]],
   [CodeProcessPublisher, [ServiceProvider]],
   [DefinitionsDbContext, [DbContextOptions]],
+  [EventDelivery, [RuntimeDbContext, WorkflowEngine, IWorkflowDefinitions, WorkflowLanguages, ServiceProvider]],
   [EventsController, [IWorkflowRuntime]],
   [FolderReferences, [DefinitionsDbContext]],
   [InstancesController, [IWorkflowRuntime, IWorkflowDefinitions]],
   [ProcessesController, [IWorkflowDefinitions]],
   [ProcessFolderLookup, [DefinitionsDbContext]],
+  [ProcessPartitionLookup, [DefinitionsDbContext, WorkflowLanguages, ServiceProvider]],
   [ProcessReferences, [DefinitionsDbContext]],
   [RunLimits, [RuntimeDbContext, WorkflowEngine, IWorkflowDefinitions]],
   [RuntimeDbContext, [DbContextOptions]],
-  [Schedules, [RuntimeDbContext, WorkflowEngine, IWorkflowDefinitions]],
+  [RuntimeProcessUsage, [RuntimeDbContext]],
+  [Schedules, [RuntimeDbContext, WorkflowEngine, IWorkflowDefinitions, WorkflowLanguages, ServiceProvider]],
   [TaskEvents, [TasksDbContext]],
   [TasksController, [IWorkflowTasks]],
   [TasksDbContext, [DbContextOptions]],
   [TimerStep, [RuntimeDbContext, WorkflowEngine]],
-  [ToolStep, [RuntimeDbContext, WorkflowEngine, WorkflowTools]],
-  [WorkflowDefinitions, [DefinitionsDbContext, WorkflowTools, CodeProcessCatalog, WorkflowClock, WorkflowEvents, WorkflowLanguages, ServiceProvider]],
+  [ToolStep, [RuntimeDbContext, WorkflowEngine, WorkflowTools, WorkflowReferences, WorkflowLanguages]],
+  [WorkflowDefinitions, [DefinitionsDbContext, WorkflowTools, CodeProcessCatalog, WorkflowClock, WorkflowEvents, WorkflowLanguages, WorkflowReferences, ServiceProvider]],
   [WorkflowEngine, [RuntimeDbContext, IWorkflowDefinitions, GraphCache, WorkflowEvents, WorkflowClock]],
   [WorkflowEvents, [EventBus, ServiceProvider, "optional:Logger"]],
   [WorkflowLanguages, ["Config:workflow"]],
+  [WorkflowReferences, [IAccessCatalog, WorkflowTools, ServiceProvider]],
   [WorkflowRetention, [ServiceProvider, "Config:workflow"]],
-  [WorkflowRuntime, [RuntimeDbContext, WorkflowEngine, IWorkflowDefinitions, ServiceProvider, WorkflowLanguages]],
+  [WorkflowRuntime, [RuntimeDbContext, WorkflowEngine, EventDelivery, IWorkflowDefinitions, ServiceProvider, WorkflowLanguages]],
   [WorkflowTasks, [TasksDbContext, IWorkflowRuntime, WorkflowClock, WorkflowEvents]],
   [WorkflowTools, [ServiceProvider]],
   [WorkflowWorker, [ServiceProvider, "Config:workflow"]],

package/core/workflow/index.ts

@@ -33,6 +33,7 @@ export {
 export {
   IWorkflowRuntime,
   type CancelInstance,
+  type EmitCause,
   type EmitOptions,
   type EmitResult,
   type HistoryEntry,
@@ -41,6 +42,9 @@ export {
   type InstanceSummary,
   type RetryInstance,
   type StartInstance,
+  type StartMany,
+  type StartManyItem,
+  type StartManyResult,
   type TokenDetails,
 } from "./runtime_module/services/IWorkflowRuntime.service";
 export {
@@ -65,6 +69,7 @@ export type { InstanceStatus, StartedVia } from "./runtime_module/model/WfInstan
 export type { TokenStatus } from "./runtime_module/model/WfToken.model";
 export { WorkflowInputValidator, DefaultWorkflowInputValidator, type WorkflowInputContext } from "./contracts/WorkflowInputValidator";
 export { WorkflowExtensions, DefaultWorkflowExtensions, type ExtensionTarget, type WorkflowPortContext } from "./contracts/WorkflowExtensions";
+export { WorkflowPartitions, DefaultWorkflowPartitions, type ProcessPartition } from "./contracts/WorkflowPartitions";
 export { WorkflowError, type WorkflowErrorCode } from "./contracts/WorkflowError";
 export type { WorkflowActor, WorkflowAuditOptions, WorkflowPage, WorkflowPaging, WorkflowRequest, WorkflowToolMetadata } from "./contracts/types";