@sixb/core 0.0.1

package/src/rules/builders.ts

@@ -0,0 +1,126 @@
+import {
+  allPredicates,
+  anyPredicates,
+  createLinkPredicateBuilder as createSharedLinkPredicateBuilder,
+  createPropertyPredicateBuilder as createSharedPropertyPredicateBuilder,
+  notPredicate,
+  type RuntimePropertyPredicateBuilder,
+} from "../predicates"
+import { RuleValidationError } from "./errors"
+import type {
+  RuleBuilder,
+  RuleDefinition,
+  RuleLinkPredicateBuilder,
+  RuleObjectType,
+  RulePredicate,
+  RulePropertyPredicate,
+} from "./types"
+import { assertRulePredicateShape } from "./validation"
+
+/**
+ * Runtime builders stay deliberately concrete.
+ *
+ * The public overload below provides typed property/link keys to callers, while
+ * this internal shape keeps the implementation simple and avoids asking
+ * TypeScript to instantiate the full ontology mapped type while checking this
+ * file.
+ */
+type RuntimeRulePropertyPredicateBuilder = RuntimePropertyPredicateBuilder<RulePropertyPredicate>
+
+type RuntimeRuleSubjectBuilder = {
+  p: Record<string, RuntimeRulePropertyPredicateBuilder>
+  l: Record<string, RuleLinkPredicateBuilder>
+  all(...predicates: RulePredicate[]): RulePredicate
+  any(...predicates: RulePredicate[]): RulePredicate
+  not(predicate: RulePredicate): RulePredicate
+}
+
+function assertNonEmpty(value: string, field: string): void {
+  if (!value.trim()) {
+    throw new RuleValidationError(`Rule ${field} must not be empty.`)
+  }
+}
+
+/** Build the `tx.p.<propertyId>` API for one ontology property. */
+function createPropertyPredicateBuilder(propertyId: string): RuntimeRulePropertyPredicateBuilder {
+  return createSharedPropertyPredicateBuilder(propertyId, {
+    subject: "Rule",
+    createError: (message) => new RuleValidationError(message),
+  })
+}
+
+/** Build the `tx.l.<linkId>` API for one ontology link. */
+function createLinkPredicateBuilder(linkId: string): RuleLinkPredicateBuilder {
+  return createSharedLinkPredicateBuilder(linkId)
+}
+
+/**
+ * Build the callback subject from ontology metadata.
+ *
+ * This object is only used while `.where(...)` executes. The returned
+ * RuleDefinition stores the predicate data produced by these methods, not this
+ * builder object or the user callback.
+ */
+function createRuleSubjectBuilder<TObjectType extends RuleObjectType>(
+  objectType: TObjectType
+): RuntimeRuleSubjectBuilder {
+  const properties = Object.fromEntries(
+    objectType.properties.map((property) => [
+      property.id,
+      createPropertyPredicateBuilder(property.id),
+    ])
+  )
+
+  const links = Object.fromEntries(
+    objectType.links.map((link) => [link.id, createLinkPredicateBuilder(link.id)])
+  )
+
+  return {
+    p: properties,
+    l: links,
+    all(...predicates: RulePredicate[]): RulePredicate {
+      return allPredicates(predicates)
+    },
+    any(...predicates: RulePredicate[]): RulePredicate {
+      return anyPredicates(predicates)
+    },
+    not(predicate: RulePredicate): RulePredicate {
+      return notPredicate(predicate)
+    },
+  }
+}
+
+/**
+ * Define an inert business rule.
+ *
+ * The overload preserves literal ids and typed property/link keys for users.
+ * The implementation returns a concrete builder and casts at the boundary so
+ * runtime code stays small while callers still get the typed DSL.
+ */
+export function defineRule<const TId extends string>(id: TId): RuleBuilder<TId>
+export function defineRule(id: string): RuleBuilder<string> {
+  assertNonEmpty(id, "id")
+
+  const builder = {
+    on(objectType: RuleObjectType) {
+      return {
+        where(callback: (subject: RuntimeRuleSubjectBuilder) => RulePredicate): RuleDefinition {
+          const predicate = callback(createRuleSubjectBuilder(objectType))
+          assertRulePredicateShape(predicate)
+
+          return {
+            kind: "rule",
+            id,
+            subject: {
+              kind: "object",
+              objectTypeId: objectType.id,
+            },
+            predicate,
+          }
+        },
+      }
+    },
+  }
+
+  return builder as unknown as RuleBuilder<string>
+}

package/src/rules/dependencies.ts

@@ -0,0 +1,76 @@
+import type { RuleDefinition, RuleEventDependency, RulePredicate } from "./types"
+
+/**
+ * Derive the event surface that can change whether a rule is active.
+ *
+ * Every object-scoped rule depends on object mutations for its subject type.
+ * Link predicates also depend on link mutations for the referenced links.
+ */
+export function deriveRuleEventDependencies(rule: RuleDefinition): readonly RuleEventDependency[] {
+  const dependencies: RuleEventDependency[] = [
+    {
+      type: "object.created",
+      objectTypeId: rule.subject.objectTypeId,
+    },
+    {
+      type: "object.updated",
+      objectTypeId: rule.subject.objectTypeId,
+    },
+    {
+      type: "object.deleted",
+      objectTypeId: rule.subject.objectTypeId,
+    },
+  ]
+
+  const linkIds: string[] = []
+  const seenLinkIds = new Set<string>()
+  collectLinkPredicateIds(rule.predicate, linkIds, seenLinkIds)
+
+  for (const linkId of linkIds) {
+    dependencies.push(
+      {
+        type: "link.created",
+        sourceTypeId: rule.subject.objectTypeId,
+        linkId,
+      },
+      {
+        type: "link.updated",
+        sourceTypeId: rule.subject.objectTypeId,
+        linkId,
+      },
+      {
+        type: "link.deleted",
+        sourceTypeId: rule.subject.objectTypeId,
+        linkId,
+      }
+    )
+  }
+
+  return dependencies
+}
+
+/** Collect unique link ids in first-seen order so dependency output is stable. */
+function collectLinkPredicateIds(
+  predicate: RulePredicate,
+  target: string[],
+  seen: Set<string>
+): void {
+  if (predicate.kind === "link") {
+    if (!seen.has(predicate.linkId)) {
+      seen.add(predicate.linkId)
+      target.push(predicate.linkId)
+    }
+    return
+  }
+
+  if (predicate.kind === "not") {
+    collectLinkPredicateIds(predicate.predicate, target, seen)
+    return
+  }
+
+  if (predicate.kind === "all" || predicate.kind === "any") {
+    for (const child of predicate.predicates) {
+      collectLinkPredicateIds(child, target, seen)
+    }
+  }
+}

package/src/rules/errors.ts

@@ -0,0 +1,11 @@
+/**
+ * Base error for the rules module. `RuleValidationError` covers invalid rule
+ * definitions both at builder time and during runtime startup validation.
+ */
+export class RuleError extends Error {
+  readonly name: string = "RuleError"
+}
+
+export class RuleValidationError extends RuleError {
+  override readonly name = "RuleValidationError"
+}

package/src/rules/index.ts

@@ -0,0 +1,30 @@
+export { defineRule } from "./builders"
+export { deriveRuleEventDependencies } from "./dependencies"
+export { RuleError, RuleValidationError } from "./errors"
+export type {
+  RuleAllPredicate,
+  RuleAnyPredicate,
+  RuleBuilder,
+  RuleDefinition,
+  RuleEventDependency,
+  RuleLinkOperator,
+  RuleLinkPredicate,
+  RuleLinkPredicateBuilder,
+  RuleNotPredicate,
+  RuleObjectType,
+  RulePredicate,
+  RulePropertyOperator,
+  RulePropertyPredicate,
+  RulePropertyPredicateBuilder,
+  RuleSubject,
+  RuleSubjectBuilder,
+  RuleValue,
+  RuleWhereBuilder,
+} from "./types"
+export {
+  assertRuleDefinition,
+  assertRulePredicateShape,
+  isRuleDefinition,
+  isRuleValue,
+  validateRulesAtStartup,
+} from "./validation"

package/src/rules/internal.ts

@@ -0,0 +1,8 @@
+/**
+ * What this repo's own packages need from the rules module, and nothing else.
+ *
+ * The rules worker and the server's rules route both derive a rule's event dependencies to decide
+ * which events wake it. That derivation is plumbing, not authoring API, so it lives here rather than
+ * on the `@sixb/core` root — see the export-surface rules in `AGENTS.md`.
+ */
+export { deriveRuleEventDependencies } from "./dependencies"

package/src/rules/types.ts

@@ -0,0 +1,113 @@
+import type { ObjectLink, ObjectType, Property } from "../ontology/types"
+import type {
+  AllPredicate,
+  AnyPredicate,
+  LinkPredicate,
+  LinkPredicateBuilder,
+  LinkPredicateOperator,
+  NotPredicate,
+  Predicate,
+  PredicateValue,
+  PropertyPredicate,
+  PropertyPredicateBuilder,
+  PropertyPredicateOperator,
+} from "../predicates"
+
+export interface RuleDefinition<
+  TId extends string = string,
+  TObjectType extends RuleObjectType = RuleObjectType,
+> {
+  /** Inert marker used by discovery and runtime registration. */
+  readonly kind: "rule"
+  readonly id: TId
+  /** The ontology entity kind this rule evaluates against. V1 supports objects only. */
+  readonly subject: RuleSubject<TObjectType["id"]>
+  /** Serializable predicate AST. No executable callbacks are retained after `.where(...)`. */
+  readonly predicate: RulePredicate
+}
+
+export type RuleSubject<TObjectTypeId extends string = string> = {
+  readonly kind: "object"
+  readonly objectTypeId: TObjectTypeId
+}
+
+export type RulePredicate = Predicate
+export type RuleAllPredicate = AllPredicate
+export type RuleAnyPredicate = AnyPredicate
+export type RuleNotPredicate = NotPredicate
+export type RulePropertyOperator = PropertyPredicateOperator
+export type RulePropertyPredicate = PropertyPredicate
+export type RuleLinkOperator = LinkPredicateOperator
+export type RuleLinkPredicate = LinkPredicate
+export type RuleValue = PredicateValue
+
+/**
+ * Minimal event filters a future rule runtime can use before evaluation.
+ *
+ * The events runtime filters by event type only today, so payload-level filtering is
+ * intentionally represented as data here rather than encoded in subscriptions.
+ */
+export type RuleEventDependency =
+  | {
+      readonly type: "object.created" | "object.updated" | "object.deleted"
+      readonly objectTypeId: string
+    }
+  | {
+      readonly type: "link.created" | "link.updated" | "link.deleted"
+      readonly sourceTypeId: string
+      readonly linkId: string
+    }
+
+export type RuleObjectType = Pick<ObjectType, "id" | "properties" | "links">
+
+type PropertyIdOf<TObjectType extends RuleObjectType> = TObjectType["properties"][number]["id"]
+
+type PropertyById<
+  TObjectType extends RuleObjectType,
+  TPropertyId extends PropertyIdOf<TObjectType>,
+> = Extract<TObjectType["properties"][number], { id: TPropertyId }>
+
+type LinkIdOf<TObjectType extends RuleObjectType> = TObjectType["links"][number]["id"]
+
+type LinkById<TObjectType extends RuleObjectType, TLinkId extends LinkIdOf<TObjectType>> = Extract<
+  TObjectType["links"][number],
+  { id: TLinkId }
+>
+
+export type RulePropertyPredicateBuilder<_TProperty extends Property = Property> =
+  PropertyPredicateBuilder<_TProperty>
+
+export type RuleLinkPredicateBuilder<_TLink extends ObjectLink = ObjectLink> =
+  LinkPredicateBuilder<_TLink>
+
+export type RuleSubjectBuilder<TObjectType extends RuleObjectType> = {
+  /** Property predicates keyed by the selected object type's property ids. */
+  readonly p: {
+    readonly [TPropertyId in PropertyIdOf<TObjectType>]: RulePropertyPredicateBuilder<
+      PropertyById<TObjectType, TPropertyId>
+    >
+  }
+  /** Link predicates keyed by the selected object type's link ids. */
+  readonly l: {
+    readonly [TLinkId in LinkIdOf<TObjectType>]: RuleLinkPredicateBuilder<
+      LinkById<TObjectType, TLinkId>
+    >
+  }
+  /** Logical AND group. Empty groups are rejected during startup validation. */
+  all(...predicates: RulePredicate[]): RulePredicate
+  /** Logical OR group. Empty groups are rejected during startup validation. */
+  any(...predicates: RulePredicate[]): RulePredicate
+  not(predicate: RulePredicate): RulePredicate
+}
+
+export interface RuleWhereBuilder<TId extends string, TObjectType extends RuleObjectType> {
+  where(
+    predicate: (subject: RuleSubjectBuilder<TObjectType>) => RulePredicate
+  ): RuleDefinition<TId, TObjectType>
+}
+
+export interface RuleBuilder<TId extends string> {
+  on<const TObjectType extends RuleObjectType>(
+    objectType: TObjectType
+  ): RuleWhereBuilder<TId, TObjectType>
+}

package/src/rules/validation.ts

@@ -0,0 +1,153 @@
+import type { OntologyRegistry } from "../ontology/registry"
+import type { ObjectType } from "../ontology/types"
+import { assertPredicateShape, isPredicateValue } from "../predicates"
+import { RuleValidationError } from "./errors"
+import type { RuleDefinition, RulePredicate, RuleValue } from "./types"
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function assertNonEmptyString(
+  value: unknown,
+  field: string,
+  createError: (message: string) => Error
+): asserts value is string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw createError(`${field} must not be empty.`)
+  }
+}
+
+export function isRuleValue(value: unknown): value is RuleValue {
+  return isPredicateValue(value)
+}
+
+/**
+ * Validate only the portable AST shape.
+ *
+ * This is used by discovery/type guards and by the builder after `.where(...)`.
+ * Ontology-aware checks live in `validateRulesAtStartup`, once the full
+ * registry has inherited properties and links resolved.
+ */
+export function assertRulePredicateShape(
+  value: unknown,
+  createError: (message: string) => Error = (message) => new RuleValidationError(message)
+): asserts value is RulePredicate {
+  assertPredicateShape(value, { subject: "Rule", createError })
+}
+
+/** Validate the serializable rule envelope without consulting ontology state. */
+export function assertRuleDefinition(
+  value: unknown,
+  createError: (message: string) => Error = (message) => new RuleValidationError(message)
+): asserts value is RuleDefinition {
+  if (!isRecord(value)) {
+    throw createError("Rule definition must be an object.")
+  }
+
+  if (value.kind !== "rule") {
+    throw createError("Rule definition kind must be 'rule'.")
+  }
+
+  assertNonEmptyString(value.id, "Rule id", createError)
+
+  if (!isRecord(value.subject) || value.subject.kind !== "object") {
+    throw createError(`Rule '${value.id}' subject must be an object subject.`)
+  }
+
+  assertNonEmptyString(
+    value.subject.objectTypeId,
+    `Rule '${value.id}' subject objectTypeId`,
+    createError
+  )
+  assertRulePredicateShape(value.predicate, createError)
+}
+
+export function isRuleDefinition(value: unknown): value is RuleDefinition {
+  try {
+    assertRuleDefinition(value, (message) => new Error(message))
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Validate rules after the ontology registry is built.
+ *
+ * Startup is where we can reject references that cannot be known from the
+ * serialized rule alone: duplicate ids, unknown subject types, unknown
+ * properties/links, and empty logical groups.
+ */
+export function validateRulesAtStartup(
+  rules: readonly RuleDefinition[],
+  ontology: OntologyRegistry
+): void {
+  const seenRuleIds = new Set<string>()
+
+  for (const rule of rules) {
+    assertRuleDefinition(rule)
+
+    if (seenRuleIds.has(rule.id)) {
+      throw new RuleValidationError(`Duplicate rule id: ${rule.id}`)
+    }
+    seenRuleIds.add(rule.id)
+
+    const objectType = ontology.getObjectTypeById(rule.subject.objectTypeId)
+    if (!objectType) {
+      throw new RuleValidationError(
+        `Rule "${rule.id}": unknown object type "${rule.subject.objectTypeId}".`
+      )
+    }
+
+    validatePredicateAgainstSubject(rule, objectType, rule.predicate)
+  }
+}
+
+/** Walk every predicate node and check subject-scoped references. */
+function validatePredicateAgainstSubject(
+  rule: RuleDefinition,
+  objectType: ObjectType,
+  predicate: RulePredicate
+): void {
+  if (predicate.kind === "all" || predicate.kind === "any") {
+    if (predicate.predicates.length === 0) {
+      throw new RuleValidationError(
+        `Rule "${rule.id}": ${predicate.kind} predicate must contain at least one predicate.`
+      )
+    }
+
+    for (const child of predicate.predicates) {
+      validatePredicateAgainstSubject(rule, objectType, child)
+    }
+    return
+  }
+
+  if (predicate.kind === "not") {
+    validatePredicateAgainstSubject(rule, objectType, predicate.predicate)
+    return
+  }
+
+  if (predicate.kind === "property") {
+    const propertyIds = new Set(objectType.properties.map((property) => property.id))
+    if (!propertyIds.has(predicate.propertyId)) {
+      throw new RuleValidationError(
+        `Rule "${rule.id}": unknown property "${predicate.propertyId}" on object type "${objectType.id}".`
+      )
+    }
+    return
+  }
+
+  if (predicate.kind === "field") {
+    throw new RuleValidationError(
+      `Rule "${rule.id}": field predicates are not supported in rule conditions.`
+    )
+  }
+
+  const linkIds = new Set(objectType.links.map((link) => link.id))
+  if (!linkIds.has(predicate.linkId)) {
+    throw new RuleValidationError(
+      `Rule "${rule.id}": unknown link "${predicate.linkId}" on object type "${objectType.id}".`
+    )
+  }
+}

package/src/runtime/create.ts

@@ -0,0 +1,163 @@
+import { resolve } from "node:path"
+import type { ActionDefinition } from "../actions"
+import type { AgentDefinition } from "../agents"
+import type { SixbAuthConfig } from "../auth"
+import type { BlobStorage } from "../blob-storage"
+import {
+  discoverActions,
+  discoverAgents,
+  discoverConnectors,
+  discoverDatasets,
+  discoverGroups,
+  discoverMembershipPolicies,
+  discoverOntologySources,
+  discoverPipelines,
+  discoverProjections,
+  discoverRoles,
+  discoverRules,
+  discoverSchedules,
+  discoverSyncs,
+  discoverWorkflows,
+} from "../bootstrap"
+import type { Broker } from "../broker"
+import type { ConnectorDefinition } from "../connectors/types"
+import type { DatasetDefinition } from "../datasets"
+import type { SixbErrorHandler } from "../error-reporting/types"
+import type { LakeStorage } from "../lake-storage"
+import type { LoggerProvider, ObservabilityOptions } from "../logging"
+import type { OntologyMaintenanceOptions } from "../maintenance"
+import type { PipelineDefinition } from "../pipelines/types"
+import type { ProjectionDefinition } from "../projections/types"
+import type { Queues } from "../queues"
+import type { RuleDefinition } from "../rules"
+import type { SandboxFactory } from "../sandboxes"
+import type { ScheduleDefinition } from "../schedules"
+import type { GroupDefinition, MembershipPolicyDefinition, RoleDefinition } from "../security"
+import type { Storage } from "../storage"
+import type { SyncDefinition } from "../syncs"
+import type { WorkflowDefinition } from "../workflows"
+import { RuntimeError } from "./errors"
+import { Sixb } from "./sixb"
+import type { OntologySource } from "./types"
+
+export interface CreateSixbOptions {
+  id?: string
+  broker: Broker
+  storage: Storage
+  lakeStorage: LakeStorage
+  blobStorage: BlobStorage
+  queues: Queues
+  sandboxes?: SandboxFactory
+  /** Optional process-level output provider. Omit for broker-only logging. */
+  logger?: LoggerProvider
+  /** Broker capture controls, independent from the output provider. */
+  observability?: ObservabilityOptions
+  /** Observes runtime failures without changing their outcome. */
+  onError?: SixbErrorHandler
+  /** Recovery and retention settings. The runtime constructor never starts maintenance timers. */
+  ontologyMaintenance?: OntologyMaintenanceOptions
+  ontologies?: readonly OntologySource[]
+  actions?: readonly ActionDefinition[]
+  /** Agent definitions to register in addition to auto-discovered `agents/` exports. */
+  agents?: readonly AgentDefinition[]
+  datasets?: readonly DatasetDefinition[]
+  /** Connector definitions to register in addition to auto-discovered `connectors/` exports. */
+  connectors?: readonly ConnectorDefinition[]
+  schedules?: readonly ScheduleDefinition[]
+  syncs?: readonly SyncDefinition[]
+  pipelines?: readonly PipelineDefinition[]
+  projections?: readonly ProjectionDefinition[]
+  rules?: readonly RuleDefinition[]
+  workflows?: readonly WorkflowDefinition[]
+  groups?: readonly GroupDefinition[]
+  roles?: readonly RoleDefinition[]
+  membershipPolicies?: readonly MembershipPolicyDefinition[]
+  auth?: SixbAuthConfig
+  projectRoot?: string
+}
+
+/**
+ * Create a Sixb runtime using convention-based discovery.
+ *
+ * Sixb auto-discovers exported definitions from `ontology/`, `actions/`, `datasets/`,
+ * `connectors/`, `syncs/`, `schedules/`, `pipelines/`, `projections/`,
+ * `rules/`, `workflows/`, `agents/`, and `security/{groups,roles,policies}/`
+ * relative to `projectRoot`.
+ */
+export async function createSixb(
+  options: CreateSixbOptions
+): Promise<Sixb<readonly OntologySource[]>> {
+  const projectRoot = resolve(options.projectRoot ?? process.cwd())
+
+  const discovered = await discoverOntologySources(projectRoot)
+  const allSources = [...(options.ontologies ?? []), ...discovered]
+
+  if (allSources.length === 0) {
+    throw new RuntimeError(
+      "No ontology found. Create an 'ontology/' folder or pass 'ontologies' to createSixb()."
+    )
+  }
+
+  const [
+    actions,
+    projections,
+    schedules,
+    syncs,
+    connectors,
+    pipelines,
+    datasets,
+    rules,
+    workflows,
+    groups,
+    roles,
+    membershipPolicies,
+    agents,
+  ] = await Promise.all([
+    discoverActions(projectRoot),
+    discoverProjections(projectRoot),
+    discoverSchedules(projectRoot),
+    discoverSyncs(projectRoot),
+    discoverConnectors(projectRoot),
+    discoverPipelines(projectRoot),
+    discoverDatasets(projectRoot),
+    discoverRules(projectRoot),
+    discoverWorkflows(projectRoot),
+    discoverGroups(projectRoot),
+    discoverRoles(projectRoot),
+    discoverMembershipPolicies(projectRoot),
+    discoverAgents(projectRoot),
+  ])
+
+  // Explicit definitions come first so local setup can override ordering while duplicate ids are
+  // still rejected by the Sixb constructor. Every family merges — `actions` and `projections` used to
+  // *replace* discovery instead, silently and undocumented.
+  return new Sixb<readonly OntologySource[]>({
+    id: options.id,
+    ontology: allSources,
+    broker: options.broker,
+    storage: options.storage,
+    lakeStorage: options.lakeStorage,
+    blobStorage: options.blobStorage,
+    queues: options.queues,
+    sandboxes: options.sandboxes,
+    logger: options.logger,
+    observability: options.observability,
+    onError: options.onError,
+    ontologyMaintenance: options.ontologyMaintenance,
+    projectRoot,
+    actions: [...(options.actions ?? []), ...actions],
+    datasets: [...(options.datasets ?? []), ...datasets],
+    connectors: [...(options.connectors ?? []), ...connectors],
+    schedules: [...(options.schedules ?? []), ...schedules],
+    syncs: [...(options.syncs ?? []), ...syncs],
+    pipelines: [...(options.pipelines ?? []), ...pipelines],
+    projections: [...(options.projections ?? []), ...projections],
+    rules: [...(options.rules ?? []), ...rules],
+    workflows: [...(options.workflows ?? []), ...workflows],
+    groups: [...(options.groups ?? []), ...groups],
+    roles: [...(options.roles ?? []), ...roles],
+    membershipPolicies: [...(options.membershipPolicies ?? []), ...membershipPolicies],
+    agents: [...(options.agents ?? []), ...agents],
+    auth: options.auth,
+  })
+}

package/src/runtime/errors.ts

@@ -0,0 +1,8 @@
+/**
+ * Thrown for runtime setup, lifecycle, and internal invariant failures
+ * that are not validation errors (e.g., duplicate registrations, missing
+ * bootstrap resources, failed event appends, module load failures).
+ */
+export class RuntimeError extends Error {
+  readonly name = "RuntimeError"
+}