Ontology<V> enum

The high-level Knowledge Domains or business-level functional areas this Cell governs.

Type: String (Comma-separated or specific identifier) Mutability: Static Pillar (Invariant)

When to use

Specify this if you want to group cells by business area (e.g., 'Finance', 'Security') for scoped observation or audit reporting.

How it works

The framework uses this for affinity routing and constraint scoping. Pulses can be broadcast to all cells in a given domain.

Non‑obvious

This is a static pillar – once set, it cannot be changed via evolve. This ensures that a cell's functional area doesn't drift.

Example

// Domains: 'Finance, PII'
if (context.domains?.contains('PII') ?? false) {
  redactSensitiveData(pulse.payload);
}

See Also:

• Ontology.subDomains: For granularity within domains.
• Context.domains: The runtime getter.

The collection of origins, upstream interfaces, or sensory inputs from which this context derives its information.

Type: String (Comma-separated) Mutability: Static Pillar (Invariant)

When to use

Set this if your cell ingests data from specific external systems or APIs, to establish trust and provenance.

How it works

The framework uses this for conflict resolution and security enforcement. It helps prevent "Source Injection" attacks.

Example

// DataSources: 'Auth_Service, User_DB'
if (!context.dataSources?.contains('Auth_Service') ?? true) {
  throw SecurityException("Unauthorized Data Origin");
}

See Also:

• Context.dataSources: The runtime getter.

The formal Categorical Identity and functional archetype of the Cell.

Type: String (or a specialized Taxonomy identifier) Mutability: Static Pillar (Invariant)

When to use

Use this to define what the cell is (e.g., 'Repository', 'Gateway'). This is often set automatically by context factories like Context.core.

How it works

The taxonomy dictates expected behavior and interface contracts. It is used for capability discovery and protocol enforcement.

Non‑obvious

As a static pillar, a cell's taxonomy cannot be changed after creation. This prevents identity drift – an 'Audit_Log' can't become a 'Mutable_Cache'.

Example

// Taxonomy: 'Audit_Repository'
if (context.taxonomy == 'Audit_Repository') {
  enforceCausalIntegrity(pulse);
}

See Also:

• Context.taxonomy: The runtime getter.

The Network Role or structural position of the Cell within the system's organizational graph.

Type: String (e.g., 'Principal', 'Tissue', 'Leaf') Mutability: Static Pillar (Invariant)

When to use

Set this if the cell's position in the hierarchy matters – e.g., it's a root orchestrator ('Principal') or a leaf node.

How it works

The topology is used for authority routing and discovery. A 'Leaf' node cannot override the governance of a 'Principal' node.

Example

// Topology: 'Principal'
if (context.topology == 'Principal') {
  enforceHighSovereignty(pulse);
}

See Also:

• Context.topology: The runtime getter.

The Structural Revision or schema version of the cell's payload and governing metadata.

Type: String (Semantic Versioning recommended, e.g., '1.0.0') Mutability: Static Pillar (Invariant)

When to use

Use this to track schema versions for compatibility checks. It's useful when you have multiple versions of a cell type.

How it works

Receptors can reject pulses that use deprecated structures by checking this version.

Example

// Version: '2.1.0'
if (context.version?.startsWith('2') ?? false) {
  processV2Payload(pulse);
}

See Also:

• Context.version: The runtime getter.

The functional Category or Archetype of the signal or node, used to label the "Kind" of operation being performed.

Type: String (e.g., 'command', 'event', 'telemetry') Mutability: Evolvable (Operational Variable)

When to use

Set this to categorize a cell. This allows the system to perform high-level routing or filtering without inspecting the raw data.

How it works

The framework uses this to align Signals with Boundaries. For example, a Pulse.type('alert') can be screened by an Integrity Gate that specifically looks for the 'alert' type in the context.

Non‑obvious

While taxonomy is a static architectural identifier (what the cell is), type is a fluid operational identifier (what the current interaction is about). It is designed to match the type parameter in the Pulse factory.

Example

// Type: 'security_event'
if (context.type == 'security_event') {
  triggerHighPriorityAlert(pulse);
}

See Also:

• Pulse.type: The factory for creating typed signals.
• Context.type: The runtime getter.

The Unique Instance Name or specific label assigned to a Cell or Pulse, distinguishing it from others of the same type.

Type: String (e.g., 'Primary_Auth_Node', 'User_123_Profile') Mutability: Evolvable (Operational Variable)

When to use

Use this to name specific instances of components. While type defines what a thing is, identity defines which specific thing it is.

How it works

The framework uses this for Precise Targeting and Forensic Audit. When a Pulse moves through the fabric, its identity allows the Switching Fabric to track exactly which node initiated a change.

Non‑obvious

This dimension is Evolvable specifically to support the Deputy Pattern. When you create a proxy of a cell, its identity can be refined (e.g., from 'Auth_Node' to 'Auth_Node_ReadOnly_Proxy') to maintain clear Identity Transparency across the system.

Example

// Identity: 'Payment_Gateway_Alpha'
if (context.identity == 'Payment_Gateway_Alpha') {
  routeToHighIntegrityProcessor(pulse);
}

See Also:

• Ontology.type: For categorical labeling.
• Ontology.partOf: For structural membership.
• Context.identity: The runtime getter.

The specialized functional areas or localized operational zones within the primary domains.

Type: String (Comma-separated) Mutability: Evolvable (Operational Variable)

When to use

When you need finer-grained scoping than domains provides – e.g., refining 'Finance' into 'Tax_Calculation'.

How it works

This dimension is used for precise routing and validation. A deputy can evolve to narrow its sub‑domain scope.

Example

// SubDomains: 'Tax_Calculation, VAT'
if (context.subDomains?.contains('VAT') ?? false) {
  applyVATRules(pulse);
}

See Also:

• Context.subDomains: The runtime getter.

The collection of entities, roles, or external systems Accountable for or affected by the state transitions within this Cell.

Type: String (Comma-separated) Mutability: Evolvable (Operational Variable)

When to use

Specify who is responsible for this cell – e.g., 'Finance_Admin' or 'Compliance_Bot'. This is used for authorization and escalation.

How it works

The framework uses this for Attribute‑Based Access Control (ABAC). An actor in a pulse must match one of the stakeholders to be authorized.

Example

// Stakeholders: 'Billing_Dept, Security_Lead'
if (context.stakeholders?.contains(pulse.actor) ?? false) {
  executeAction(pulse);
}

See Also:

• Context.stakeholders: The runtime getter.

The operational rules, boundary conditions, and validation schemas enforced within the Cell.

Type: Map<String, dynamic> Mutability: Evolvable (Operational Variable)

When to use

Define runtime constraints like max_items, timeout, or read_only. This is the primary place to configure business invariants.

How it works

The framework checks these constraints during the validation phase. A deputy can tighten constraints via evolve.

Example

// Constraints: { 'max_value': 100, 'requires_auth': true }
final config = context.constraints;
if (proposedValue > (config?['max_value'] ?? 0)) {
  proposedValue = config!['max_value'];
}

See Also:

• Context.constraints: The runtime getter.

The exclusionary boundaries defining prohibited behaviors, out-of-scope responsibilities, or forbidden identities for the Cell.

Type: String (Comma-separated) Mutability: Evolvable (Operational Variable)

When to use

Explicitly define what the cell is not – e.g., 'Currency_Exchange' for a payment gateway that shouldn't handle currency conversion.

How it works

During signal processing, if a pulse requires a capability listed in isNot, the transformation is aborted.

Example

// IsNot: 'Currency_Exchange, Credit_Issuer'
if (context.isNot?.contains('Credit_Issuer') ?? false) {
  if (pulse.action == 'Credit_Limit_Increase') {
    throw SovereigntyException('Action forbidden by IsNot boundary.');
  }
}

See Also:

• Context.isNot: The runtime getter.

The Regulatory Frameworks and architectural standards mandated by this authority (e.g., 'GDPR', 'PCI-DSS', 'HIPAA').

Type: String (Comma-separated) Mutability: Evolvable (Operational Variable)

When to use

Set this if the cell must comply with specific regulations – e.g., 'GDPR' for handling European user data.

How it works

The framework uses this for boundary validation and automatic auditing. Pulses that cross compliance zones are flagged.

Example

// Compliance: 'GDPR, SOC2'
if (context.compliance?.contains('GDPR') ?? false) {
  encryptPII(pulse.payload);
}

See Also:

• Context.compliance: The runtime getter.

The structural pointer identifying the Parent Container or the ancestral system this Cell belongs to.

Type: String (Typically a Unique Identity or Taxonomy string) Mutability: Evolvable (Operational Variable)

When to use

Use this to establish the cell's lineage – e.g., which module or service it belongs to.

How it works

The framework uses this for constraint resolution (inheriting rules from the parent) and for mutual authorization handshakes.

Example

// PartOf: 'Global_Ledger_Service'
if (context.partOf == 'Global_Ledger_Service') {
  await verifyPrincipalClearance(context.partOf);
}

See Also:

• Context.partOf: The runtime getter.

Available on Enum, provided by the EnumName extension