bazis 0.132.0 → 0.134.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,6 +3,7 @@ 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 { WorkflowTools } from "../internal/WorkflowTools";
@@ -10,6 +11,7 @@ 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 +25,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 +40,17 @@ import { WorkflowDefinitions } from "./services/WorkflowDefinitions.service";
     singleton(CodeProcessCatalog),
     singleton(WorkflowLanguages),
     singleton(WorkflowExtensions, DefaultWorkflowExtensions),
+    singleton(WorkflowPartitions, DefaultWorkflowPartitions),
     scoped(WorkflowEvents),
     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, 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

@@ -10,8 +10,8 @@ import { definitionProblems, WorkflowSetupError } from "./codeProcesses";
 /**
  * At start, after the tables exist: brings over the catalog of the old store
  * (WORKFLOW-002 §9), then publishes the processes of `@Module({ processes })`
- * (WORKFLOW-001 §14). A document with an unknown Tool or an `extensions` namespace
- * nobody checks stops the start with every finding of every process; the same
+ * (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.
  */
 export class CodeProcessPublisher implements HostedService {
@@ -30,10 +30,11 @@ export class CodeProcessPublisher implements HostedService {
       const tools = this.services.resolve(WorkflowTools);
       const definitions = scope.resolve(IWorkflowDefinitions);
       const problems: string[] = [];
+      const processes = entries.map(({ process }) => process.key);
       for (const { process, module } of entries) {
         const found = [...definitionProblems(process, (name) => tools.has(name))];
-        for (const issue of await definitions.validate(process.document)) {
-          if (issue.severity === "error" && (issue.code === "extension_unknown" || issue.code === "extension_invalid")) found.push(`${issue.message} (${issue.code})`);
+        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})`);
         }
         if (found.length > 0) problems.push(`${module}: process "${process.key}":\n${found.map((line) => `  - ${line}`).join("\n")}`);
       }

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);
@@ -122,7 +132,8 @@ export class ProcessesController {
   async validate(ctx: HttpContext) {
     const request = await body(ctx);
     const { actor, language } = await callerOf(ctx);
-    return { issues: await this.definitions.validate(request.document, { actor, language }) };
+    const key = optionalString(request.key, "key", 64);
+    return { issues: await this.definitions.validate(request.document, { actor, language, ...(key === undefined ? {} : { processes: [key] }) }) };
   }
 
   /** What a designer builds its forms from (WORKFLOW-002 §4.2). */
@@ -143,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

@@ -76,6 +76,8 @@ export interface ProcessListQuery extends WorkflowPaging {
 export interface ValidateOptions {
   readonly language?: string;
   readonly actor?: WorkflowActor;
+  /** Keys that count as published besides the catalog: the process itself, processes of the code about to be published. */
+  readonly processes?: readonly string[];
 }
 
 export interface SaveDraftOptions extends WorkflowAuditOptions, Pick<ValidateOptions, "language"> {
@@ -100,6 +102,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. */
@@ -107,6 +111,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>;
   /**

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

@@ -8,6 +8,8 @@ import { isUuid, pageQueryOf, type WorkflowActor, type WorkflowAuditOptions, typ
 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";
@@ -83,10 +85,21 @@ 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 issues = validateProcess(document, { tools: (name) => this.workflowTools.has(name), extensions: (namespace) => namespaces.has(namespace) });
+    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;
     const context: WorkflowPortContext = { partition: null, language: options.language ?? this.languages.default, actor: options.actor ?? null };
     const found: ProcessIssue[] = [...issues];
@@ -151,6 +164,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);
@@ -178,7 +204,7 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
       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, ...(options.language === undefined ? {} : { language: options.language }) });
+      const issues = await this.validate(row.draft, { actor, processes: [key], ...(options.language === undefined ? {} : { language: options.language }) });
       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

@@ -8,6 +8,7 @@ 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";
@@ -22,7 +23,11 @@ import { WorkflowRetention } from "../runtime_module/background/WorkflowRetentio
 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";
@@ -38,17 +43,22 @@ import { WorkflowTasks } from "../tasks_module/services/WorkflowTasks.service";
 
 registerFrameworkClassDeps([
   [CatalogImport, [DefinitionsDbContext, WorkflowLanguages]],
+  [ChildCalls, [RuntimeDbContext, WorkflowEngine, IWorkflowDefinitions, ServiceProvider, WorkflowLanguages]],
   [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]],
@@ -59,7 +69,7 @@ registerFrameworkClassDeps([
   [WorkflowEvents, [EventBus, ServiceProvider, "optional:Logger"]],
   [WorkflowLanguages, ["Config:workflow"]],
   [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";
 

package/core/workflow/runtime_module/WorkflowRuntime.module.ts

@@ -1,13 +1,18 @@
 import { AccessModule } from "../../access";
 import { Module, scoped, singleton } from "../../di";
 import { DefaultWorkflowInputValidator, WorkflowInputValidator } from "../contracts/WorkflowInputValidator";
+import { WorkflowProcessUsage } from "../contracts/WorkflowProcessUsage";
 import { WorkflowDefinitionsModule } from "../definitions_module/WorkflowDefinitions.module";
 import { runtimePermissions } from "./access/Runtime.permissions";
 import { WorkflowRetention } from "./background/WorkflowRetention";
 import { WorkflowWorker } from "./background/WorkflowWorker";
 import { EventsController } from "./http/Events.controller";
 import { InstancesController } from "./http/Instances.controller";
+import { ChildCalls } from "./internal/ChildCalls";
+import { EventDelivery } from "./internal/EventDelivery";
 import { GraphCache } from "./internal/GraphCache";
+import { RunLimits } from "./internal/RunLimits";
+import { RuntimeProcessUsage } from "./internal/RuntimeProcessUsage";
 import { Schedules } from "./internal/Schedules";
 import { TimerStep } from "./internal/TimerStep";
 import { ToolStep } from "./internal/ToolStep";
@@ -31,6 +36,10 @@ import { WorkflowRuntime } from "./services/WorkflowRuntime.service";
     scoped(ToolStep),
     scoped(TimerStep),
     scoped(Schedules),
+    scoped(ChildCalls),
+    scoped(RunLimits),
+    scoped(EventDelivery),
+    scoped(WorkflowProcessUsage, RuntimeProcessUsage),
     singleton(WorkflowInputValidator, DefaultWorkflowInputValidator),
     scoped(IWorkflowRuntime, WorkflowRuntime),
   ],

package/core/workflow/runtime_module/background/WorkflowRetention.ts

@@ -10,7 +10,7 @@ import type { WorkflowSettings } from "../../contracts/Workflow.config";
 const DAY_MS = 86_400_000;
 
 /**
- * Deletes `completed` and `cancelled` instances older than their process's
+ * Deletes `completed`, `cancelled` and `timedOut` instances older than their process's
  * `retentionDays`, with tokens, jobs, subscriptions and history (by cascade),
  * `retention.batchSize` at a time. `failed` instances wait for a person and stay.
  * Each deleted batch is published as `WORKFLOW_INSTANCES_DELETED`, so parts
@@ -52,7 +52,7 @@ export class WorkflowRetention extends BackgroundService {
         for (;;) {
           if (signal?.aborted) return deleted;
           const ids = (await db.instances.asNoTracking()
-            .where((i) => i.processKey.eq(policy.key).and(i.status.in(["completed", "cancelled"])).and(i.endedAt.lt(cutoff)))
+            .where((i) => i.processKey.eq(policy.key).and(i.status.in(["completed", "cancelled", "timedOut"])).and(i.endedAt.lt(cutoff)))
             .orderBy((i) => i.id)
             .take(batchSize)
             .select((i) => ({ id: i.id }))

package/core/workflow/runtime_module/events/Runtime.events.ts

@@ -21,16 +21,16 @@ export interface WorkflowTaskRequested {
 export interface WorkflowTokenClosed {
   readonly instanceId: string;
   readonly tokenId: string;
-  /** `cancelled` — the instance was cancelled; `interrupted` — a boundary timer took over the step. */
-  readonly reason: "cancelled" | "interrupted";
+  /** `cancelled` — the instance was cancelled; `interrupted` — a boundary event or a skipped iteration closed the step; `timedOut` — the run took too long. */
+  readonly reason: "cancelled" | "interrupted" | "timedOut";
 }
 
-/** An instance finished: completed or cancelled. */
+/** An instance finished: completed, cancelled or out of time. */
 export interface WorkflowInstanceFinished {
   readonly instanceId: string;
   readonly processKey: string;
   readonly partition: string | null;
-  readonly status: Extract<InstanceStatus, "completed" | "cancelled">;
+  readonly status: Extract<InstanceStatus, "completed" | "cancelled" | "timedOut">;
 }
 
 /** Retention deleted these finished instances with their tokens and history. */

package/core/workflow/runtime_module/http/Instances.controller.ts

@@ -5,7 +5,7 @@ import { buildListDocument } from "../../../../library/jsonapi";
 import { body, callerOf, filterOf, listQuery, optionalString, pagingOfList, param, requiredString } from "../../internal/http";
 import type { InstanceStatus } from "../model/WfInstance.model";
 import { IWorkflowDefinitions } from "../../definitions_module/services/IWorkflowDefinitions.service";
-import { IWorkflowRuntime, type InstanceSummary } from "../services/IWorkflowRuntime.service";
+import { IWorkflowRuntime, type InstanceSummary, type StartManyItem } from "../services/IWorkflowRuntime.service";
 
 /** Instances over HTTP (WORKFLOW-001 §4); rights are `workflow.instances.*` (WORKFLOW-002 §6.2). */
 @Controller("workflow/instances")
@@ -33,12 +33,23 @@ export class InstancesController {
     return Created(`${ctx.path}/${instance.id}`, instance);
   }
 
+  /** A start per element, for an action over many records (WORKFLOW-002 §5.1). */
+  @Post("bulk")
+  @Authorize(can("workflow.instances.start"))
+  async startMany(ctx: HttpContext) {
+    const request = await body(ctx);
+    const processKey = requiredString(request.processKey, "processKey", 64);
+    const partition = optionalString(request.partition, "partition") ?? null;
+    const { actor, request: from, language } = await callerOf(ctx, "workflow.instances.start", { scope: partition, process: processKey, folder: await this.definitions.folderOf(processKey) });
+    return { data: await this.runtime.startMany(processKey, { items: request.items as readonly StartManyItem[], partition, actor, request: from, language }) };
+  }
+
   @Get()
   @Authorize(can("workflow.instances.read"))
   async list(ctx: HttpContext) {
     const { access } = await callerOf(ctx);
     const list = listQuery(ctx, {
-      filter: { partition: ["eq"], processKey: ["eq"], status: ["eq"], businessKey: ["eq"], startedById: ["eq"] },
+      filter: { partition: ["eq"], processKey: ["eq"], status: ["eq"], businessKey: ["eq"], startedById: ["eq"], parentInstanceId: ["eq"] },
       sort: ["createdAt", "endedAt", "status", "processKey"],
     });
     const page = await this.runtime.instances({
@@ -49,6 +60,7 @@ export class InstancesController {
       status: filterOf(list, "status") as InstanceStatus | undefined,
       businessKey: filterOf(list, "businessKey"),
       startedById: filterOf(list, "startedById"),
+      parentInstanceId: filterOf(list, "parentInstanceId"),
     });
     return buildListDocument(page.items, list, page.total, { basePath: ctx.path });
   }