# Architecture > Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a… Page: Ontology · Algorithms Canonical: https://banes-lab.com/ontology/algorithms#algorithms-domain-architecture Listed in [Ontology · Algorithms](https://banes-lab.com/api/pages/ontology/algorithms.md), after [Anti-patterns](https://banes-lab.com/ontology/algorithms/algorithms-domain-anti-patterns.md) and before [Architecture relationships](https://banes-lab.com/ontology/algorithms/algorithms-domain-arch-relationships.md). Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain. Relations diagram What composes what inside this domain. ```mermaid flowchart LR n_document_truth_alignment["Document Truth Alignment"] n_architectural_contract_kernel["Architectural Contract Kernel"] n_responsibility_boundary["Responsibility Boundary"] n_coupling_control["Coupling Control"] n_interface_contract["Interface Contract"] n_substitutability["Substitutability"] n_canonical_data["Canonical Data"] n_domain_boundary["Domain Boundary"] n_self_description_manifest["Self-Description Manifest"] n_runtime_discovery["Runtime Discovery"] n_extension_point["Extension Point"] n_construction_boundary["Construction Boundary"] n_structural_mediation["Structural Mediation"] n_behavioral_dispatch["Behavioral Dispatch"] n_architectural_style_boundary["Architectural Style Boundary"] n_port_adapter["Port Adapter"] n_event_messaging["Event Messaging"] n_saga_compensation["Saga Compensation"] n_transaction_boundary["Transaction Boundary"] n_idempotent_side_effect["Idempotent Side Effect"] n_deterministic_core["Deterministic Core"] n_verification_fitness["Verification Fitness"] n_error_boundary["Error Boundary"] n_resilience_control["Resilience Control"] n_recovery_deployment["Recovery Deployment"] n_observability_trace["Observability Trace"] n_causality_ordering["Causality Ordering"] n_performance_scaling["Performance Scaling"] n_cache_correctness["Cache Correctness"] n_portability_environment["Portability Environment"] n_security_policy["Security Policy"] n_control_plane["Control Plane"] n_declarative_metaprogramming["Declarative Metaprogramming"] n_streaming_dataflow["Streaming Dataflow"] n_rag_knowledge_boundary["RAG Knowledge Boundary"] n_architecture_selection_meta_algorithm["Architecture Selection Meta-Algorithm"] n_universal_architectural_concern_template["Universal Architectural Concern Template"] n_architectural_contract_algebra["Architectural Contract Algebra"] n_manifest_driven_documentation["Manifest-Driven Documentation"] n_consumer_config_ssot["Consumer Config SSOT"] n_finite_state_machine["Finite State Machine"] n_statecharts["Statecharts"] n_petri_nets["Petri Nets"] n_queuing_theory["Queuing Theory"] n_architectural_contract_algebra --> n_domain_boundary n_architectural_contract_algebra --> n_transaction_boundary n_manifest_driven_documentation --> n_document_truth_alignment n_manifest_driven_documentation --> n_self_description_manifest n_manifest_driven_documentation --> n_extension_point n_consumer_config_ssot --> n_architectural_contract_kernel n_consumer_config_ssot --> n_responsibility_boundary n_statecharts --> n_finite_state_machine ``` ### Document Truth Alignment - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [logic](https://banes-lab.com/records/reasoning/math-type-logic.md) - Yields: boolean Details Intent For any document that states facts about a codebase, separate invariant facts (counts, paths, names, and the doc-type's structural schema) from variant prose, bind each invariant to a code-derived value through a stable key, compile the document from a template, and gate the output so a stated fact can never drift from the code it describes. Invariant A document is well-formed iff every rendered invariant equals its resolved code-truth and every doc-type-required meta-concern is present in order; prose is free. Flow ```text Concern → Variant → Invariant → TruthKey → Deriver → Template → Compilation → DriftGate ``` Productions ```bnf DocumentTruth ::= "+" "→" "→" "→" "→" InvariantBinding ::= "," "," "," ``` Composes none Composed by [Manifest-Driven Documentation](https://banes-lab.com/records/algorithms/manifest-driven-documentation.md) Forces [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [modularity](https://banes-lab.com/records/force/modularity.md) Grounds none Before ```text A doc states 'the system has 12 modules' — a hand-typed count that drifts the moment a module is added. ``` After ```text invariant{moduleCount} → truth-key{modules.length} → deriver{scan workspaces} → template{'... has {moduleCount} modules'} → drift-gate{rendered == derived, else fail} ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Architectural Contract Kernel - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [computation](https://banes-lab.com/records/reasoning/math-type-computation.md) - Yields: procedure Details Intent For any programmatic system, identify architectural concerns, define explicit contracts for each concern, bind implementations to those contracts, validate invariants, observe behavior, and evolve through versioned change. Invariant Architecture is a graph of bounded contracts whose nodes expose stable intent and whose edges preserve compatibility, causality, and governance. Flow ```text Concern → Boundary → Contract → Implementation → Verification → Observation → Evolution ``` Productions ```bnf ArchitectureKernel ::= "→" "→" "→" "→" "→" "→" ConcernContract ::= "," "," "," "," "," "," ``` Composes none Composed by [Consumer Config SSOT](https://banes-lab.com/records/algorithms/consumer-config-ssot.md) Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [security_governance](https://banes-lab.com/records/force/security-governance.md), [causality_ordering](https://banes-lab.com/records/force/causality-ordering.md) Grounds none Before ```typescript class FooService { save(f) { db.write(f); log(f); notify(f); } } ``` After ```typescript interface FooPort { save(f: Foo): Promise; } class FooService implements FooPort { constructor(private repo: FooRepo, private events: EventSink) {} async save(f: Foo) { await this.repo.save(f); this.events.emit({ type: "FooSaved", f }); } } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Responsibility Boundary - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [set-theory](https://banes-lab.com/records/reasoning/math-type-set-theory.md) - Yields: set | boolean Details Intent Partition behavior into cohesive units, assign each unit one reason to change, hide internal details, expose only intentional interfaces, and reject cross-boundary leakage. Invariant Modularity is achieved when responsibility, knowledge, and change pressure are localized. Flow ```text Behavior → Responsibility → Boundary → Interface → Encapsulation → Replaceability ``` Productions ```bnf ResponsibilityBoundary ::= "→" "→" "→" "→" ModuleBoundary ::= "single_responsibility" "," "high_cohesion" "," "low_coupling" "," "information_hiding" "," "replaceable_implementation" ``` Composes none Composed by [Consumer Config SSOT](https://banes-lab.com/records/algorithms/consumer-config-ssot.md), [Cascade Layer Partition](https://banes-lab.com/records/algorithms/cascade-layer-partition.md), [Placement Isolation](https://banes-lab.com/records/algorithms/placement-isolation.md), [Assembly Composition](https://banes-lab.com/records/algorithms/assembly-composition.md) Forces [modularity](https://banes-lab.com/records/force/modularity.md), [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md) Grounds none Before ```typescript class FooUtil { parse() {} save() {} render() {} notify() {} } ``` After ```typescript class FooParser { parse() {} } class FooRepository { save() {} } class FooView { render() {} } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Coupling Control - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [graph](https://banes-lab.com/records/reasoning/math-type-graph.md) - Yields: edge-list Details Intent Detect dependency directions, invert dependencies toward abstractions, restrict imports to approved boundaries, and preserve autonomy between modules. Invariant Low coupling is enforced by making dependencies point at contracts instead of concrete implementations. Flow ```text ConcreteDependency → AbstractionBoundary → DependencyRule → ImportValidation ``` Productions ```bnf CouplingControl ::= "→" "→" "→" "→" DependencyRule ::= "depend_on_interface" | "depend_on_port" | "same_boundary_only" | "adapter_required" ``` Composes none Composed by [Constraints Over Shortcuts](https://banes-lab.com/records/algorithms/no-shortcuts.md), [Event Emission Over Parent Callbacks](https://banes-lab.com/records/algorithms/no-callbacks.md), [Least Privilege Over Broad Privilege](https://banes-lab.com/records/algorithms/no-broad-privilege.md), [Saga Compensation Over Distributed 2PC](https://banes-lab.com/records/algorithms/no-distributed-2pc.md), [Async Events Over Synchronous Cross-Boundary](https://banes-lab.com/records/algorithms/no-sync-cross-boundary.md), [Injected Dependency Over Hidden](https://banes-lab.com/records/algorithms/no-hidden-dependency.md), [Anti-Corruption Layer Over Cross-Context Leak](https://banes-lab.com/records/algorithms/no-leaky-context.md), [Placement Isolation](https://banes-lab.com/records/algorithms/placement-isolation.md) Forces [modularity](https://banes-lab.com/records/force/modularity.md), [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md) Grounds none Before ```typescript import { SqlFooStore } from "./infra/sql"; class FooService { store = new SqlFooStore(); } ``` After ```typescript interface FooStore { save(f: Foo): Promise; } class FooService { constructor(private store: FooStore) {} } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Interface Contract - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [logic](https://banes-lab.com/records/reasoning/math-type-logic.md) - Yields: boolean Details Intent Define explicit interfaces with preconditions, postconditions, invariants, error semantics, version rules, and compatibility guarantees before implementation. Invariant Interfaces are executable promises between independently changeable parts. Flow ```text Intent → Interface → Preconditions → Postconditions → Compatibility → Implementation ``` Productions ```bnf InterfaceContract ::= "," "," "," "," "," "," CompatibilityRule ::= "backward_compatible" | "forward_compatible" | "breaking_change_requires_new_version" ``` Composes none Composed by [Composed Turn Contract](https://banes-lab.com/records/algorithms/composed-turn-contract.md), [](https://banes-lab.com/records/algorithms/mode-driven-response-schema.md) Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md) Grounds none Before ```typescript function doFoo(a, b, n) {} ``` After ```typescript interface FooOp { (a: Foo, b: Bar, n: number): Result; } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Substitutability - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [logic](https://banes-lab.com/records/reasoning/math-type-logic.md) - Yields: boolean Details Intent Validate that every implementation of an abstraction preserves the abstraction’s behavior, accepts valid parent inputs, returns valid parent outputs, and does not strengthen forbidden constraints. Invariant Polymorphism is safe only when behavioral subtyping holds. Flow ```text Interface → Implementation → ContractCheck → Substitute|Reject ``` Productions ```bnf Substitutability ::= "→" "→" "→" BehavioralCompatibilityCheck ::= "preconditions_not_stronger" "," "postconditions_not_weaker" "," "invariants_preserved" "," "errors_compatible" ``` Composes none Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Grounds none Before ```typescript class ReadOnlyFooStore extends FooStore { save() { throw new Error("unsupported"); } } ``` After ```typescript interface FooReader { find(id: FooId): Foo | undefined; } interface FooWriter extends FooReader { save(f: Foo): void; } class ReadOnlyFooStore implements FooReader { find(id: FooId) { return fooCache.get(id); } } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Canonical Data - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [set-theory](https://banes-lab.com/records/reasoning/math-type-set-theory.md) - Yields: set | boolean Details Intent Normalize incoming data into a canonical schema, validate types and semantics, preserve one source of truth, and translate at system boundaries only. Invariant Semantic consistency requires one canonical model and controlled translation at edges. Flow ```text RawData → Validate → Normalize → CanonicalModel → BoundaryTranslation ``` Productions ```bnf CanonicalDataFlow ::= "→" "→" "→" "→" CanonicalModel ::= "," "," "," "," ``` Composes none Composed by [Seed Composition](https://banes-lab.com/records/algorithms/seed-composition.md), [Canonical Config Resolution](https://banes-lab.com/records/algorithms/canonical-config-resolution.md), [Composed Turn Contract](https://banes-lab.com/records/algorithms/composed-turn-contract.md), [](https://banes-lab.com/records/algorithms/mode-driven-response-schema.md), [Token Source-of-Truth](https://banes-lab.com/records/algorithms/token-source-of-truth.md), [Type-Keyed Appearance](https://banes-lab.com/records/algorithms/type-keyed-appearance.md) Forces [modularity](https://banes-lab.com/records/force/modularity.md), [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [model_governance](https://banes-lab.com/records/force/model-governance.md) Grounds none Before ```typescript function useFoo(raw) { const name = raw.name ?? raw.Name ?? raw.title; } ``` After ```typescript function toCanonicalFoo(raw: unknown): Foo { return { id: fooId(raw), name: pickName(raw) }; } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Domain Boundary - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [topology](https://banes-lab.com/records/reasoning/math-type-topology.md) - Yields: boolean Details Intent Identify bounded contexts, define the ubiquitous language and the owner of each context's model, map the relationships between contexts, and use anti-corruption layers where semantics differ. Invariant Domain architecture protects meaning by making semantic boundaries explicit. Flow ```text Domain → BoundedContext → Language → ContextMap → TranslationBoundary ``` Productions ```bnf DomainBoundary ::= "→" "→" "→" "→" IntegrationPolicy ::= "shared_kernel" | "customer_supplier" | "anti_corruption_layer" | "published_language" | "separate_ways" ``` Composes none Composed by [Architectural Contract Algebra](https://banes-lab.com/records/algorithms/architectural-contract-algebra.md), [Type-Keyed Appearance](https://banes-lab.com/records/algorithms/type-keyed-appearance.md) Forces [modularity](https://banes-lab.com/records/force/modularity.md), [semantic_consistency](https://banes-lab.com/records/force/semantic-consistency.md), [domain_boundary](https://banes-lab.com/records/force/domain-boundary.md) Grounds none Before ```typescript fooContext.use(sharedBaz); barContext.use(sharedBaz); ``` After ```typescript function toBarBaz(f: FooBaz): BarBaz { return { id: f.id }; } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Self-Description Manifest - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [set-theory](https://banes-lab.com/records/reasoning/math-type-set-theory.md) - Yields: set | boolean Details Intent Require every component to declare identity, capabilities, contracts, dependencies, configuration, health model, and version metadata in a machine-readable manifest. Invariant Runtime systems become discoverable and governable when components describe themselves. Flow ```text Component → Manifest → CapabilityDeclaration → Discovery → Validation ``` Productions ```bnf SelfDescription ::= "→" "→" "→" "→" Manifest ::= "identity" "," "version" "," "capabilities" "," "dependencies" "," "contracts" "," "configuration" "," "health" ``` Composes none Composed by [Manifest-Driven Documentation](https://banes-lab.com/records/algorithms/manifest-driven-documentation.md), [](https://banes-lab.com/records/algorithms/mode-driven-response-schema.md), [Custom Type Registration](https://banes-lab.com/records/algorithms/custom-type-registration.md) Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [model_governance](https://banes-lab.com/records/force/model-governance.md) Grounds none Before ```typescript export class FooPlugin { transform(x) { return x; } } ``` After ```typescript export const manifest = { identity: "foo-plugin", version: "1.2.0", capabilities: ["transform"], contracts: ["FooPort@1"], dependencies: [] }; ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Runtime Discovery - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [set-theory](https://banes-lab.com/records/reasoning/math-type-set-theory.md) - Yields: set | boolean Details Intent Discover available components by manifest, convention, registry, or service endpoint; validate discovered candidates against contracts; bind dynamically only after compatibility checks. Invariant Dynamic binding is safe only when discovery is filtered by explicit contracts. Flow ```text DiscoverySource → CandidateSet → ContractValidation → Binding → RuntimeUse ``` Productions ```bnf RuntimeDiscovery ::= "→" "→" "→" "→" DiscoveryMechanism ::= "manifest" | "registry" | "service_discovery" | "convention" | "configuration" ``` Composes none Composed by [Runtime Extensibility](https://banes-lab.com/records/algorithms/runtime-extensibility.md), [](https://banes-lab.com/records/algorithms/mode-driven-response-schema.md) Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md) Principle [Runtime Discovery](https://banes-lab.com/records/architecture/runtime-discovery.md) Grounds none Before ```typescript const plugin = new KnownFooPlugin(); ``` After ```typescript const candidates = registry.discover({ capability: "transform" }); const bound = candidates.filter((c) => satisfies(c.contract, FooPortV1)); ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Extension Point - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [logic](https://banes-lab.com/records/reasoning/math-type-logic.md) - Yields: boolean Details Intent Define stable extension contracts, register implementations through IoC or plugin registries, isolate plugin failures, and expose deterministic loading order. Invariant Extensibility requires stable hooks, controlled registration, and observable binding. Flow ```text ExtensionContract → PluginRegistration → DependencyInjection → Isolation → Dispatch ``` Productions ```bnf ExtensionArchitecture ::= "→" "→" "→" "→" BindingPolicy ::= "dependency_injection" | "service_registry" | "service_locator" | "manual_registration" | "auto_discovery" ``` Composes none Composed by [Manifest-Driven Documentation](https://banes-lab.com/records/algorithms/manifest-driven-documentation.md), [Composed Turn Contract](https://banes-lab.com/records/algorithms/composed-turn-contract.md), [](https://banes-lab.com/records/algorithms/mode-driven-response-schema.md), [Custom Type Registration](https://banes-lab.com/records/algorithms/custom-type-registration.md) Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [runtime_extensibility](https://banes-lab.com/records/force/runtime-extensibility.md), [correctness_verification](https://banes-lab.com/records/force/correctness-verification.md), [observability_traceability](https://banes-lab.com/records/force/observability-traceability.md) Grounds none Before ```typescript switch (kind) { case "foo": doFoo(); break; case "bar": doBar(); break; } ``` After ```typescript registry.register("foo", fooHandler); registry.register("bar", barHandler); registry.get(kind)?.handle(input); ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Construction Boundary - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [computation](https://banes-lab.com/records/reasoning/math-type-computation.md) - Yields: procedure Details Intent Hide object creation behind factories, builders, prototypes, or abstract factories so callers depend on creation contracts rather than concrete constructors. Invariant Creation logic is a boundary and should be replaceable independently from usage logic. Flow ```text CreationRequest → ConstructionContract → Factory|Builder|Prototype → Instance ``` Productions ```bnf ConstructionBoundary ::= "→" "→" "→" ConstructionStrategy ::= "factory" | "factory_method" | "abstract_factory" | "builder" | "prototype" ``` Composes none Composed by [Governed Construction Boundary](https://banes-lab.com/records/algorithms/governed-construction-boundary.md) Forces [modularity](https://banes-lab.com/records/force/modularity.md), [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [object_creation](https://banes-lab.com/records/force/object-creation.md) Grounds none Before ```typescript const c = new FooConnection(host, port, user, pw); ``` After ```typescript const c = fooConnectionFactory.create(config); ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Structural Mediation - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [algebra](https://banes-lab.com/records/reasoning/math-type-algebra.md) - Yields: ordered-structure Details Intent Insert adapters, facades, proxies, bridges, or decorators where incompatible structure, access control, abstraction separation, or behavior layering is required. Invariant Structural patterns reshape access without corrupting the core contract. Flow ```text ClientNeed → StructuralMismatch → MediatingPattern → CompatibleInterface ``` Productions ```bnf StructuralMediation ::= "→" "→" "→" StructuralPattern ::= "adapter" | "facade" | "proxy" | "bridge" | "decorator" ``` Composes none Forces [modularity](https://banes-lab.com/records/force/modularity.md), [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md) Grounds none Before ```typescript legacyFooApi.call(new FooXmlPayload(foo)); ``` After ```typescript class FooAdapter implements FooPort { constructor(private legacy: FooXmlApi) {} save(f: Foo) { return this.legacy.call(toFooXml(f)); } } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Behavioral Dispatch - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [logic](https://banes-lab.com/records/reasoning/math-type-logic.md) - Yields: boolean Details Intent Externalize variable behavior into strategies, template hooks, observers, or mediators while preserving stable orchestration contracts. Invariant Behavioral variation belongs behind dispatch contracts, not scattered conditionals. Flow ```text StableFlow → VariationPoint → DispatchPattern → RuntimeBehavior ``` Productions ```bnf BehavioralDispatch ::= "→" "→" "→" BehaviorPattern ::= "strategy" | "template_method" | "observer" | "mediator" | "polymorphic_dispatch" ``` Composes none Forces [contract_compatibility](https://banes-lab.com/records/force/contract-compatibility.md), [control_coordination](https://banes-lab.com/records/force/control-coordination.md) Grounds none Before ```typescript function handleFoo(f) { if (f.kind === "a") { return runA(f); } else if (f.kind === "b") { return runB(f); } } ``` After ```typescript const strategies: Record = { a: fooStrategyA, b: fooStrategyB }; function handleFoo(f: Foo) { return strategies[f.kind].run(f); } ``` How it is checked Checked by the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists Population Every module and boundary the contract governs Freshness A verdict stands until the module, its dependencies or the contract changes Refusal A failing fitness function or contract test blocks the release Observation The traces and health signals the observability contracts require, which locate a contract failure in production Evidence None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it Authoritative side The contract, which the module and its tests conform to Depends on Not answered Shape it refuses Not answered ### Architectural Style Boundary - Domain: [architecture](https://banes-lab.com/ontology/algorithms/algorithms-domain-architecture.md) - Tier: [leaf](https://banes-lab.com/records/vocabulary/domain-tier-leaf.md) - Math type: [optimization](https://banes-lab.com/records/reasoning/math-type-optimization.md) - Yields: boolean | ranking Details Intent Select an architectural style, from a monolith or modular monolith to layered, hexagonal or microservices, by dependency direction, deployment autonomy, domain complexity, team topology, operational maturity and change isolation needs, then enforce the style through boundary rules. Invariant Architecture style is a macro-contract for dependency flow and deployment shape. Flow ```text SystemForces → StyleSelection → BoundaryRules → FitnessValidation ``` Productions ```bnf ArchitectureStyle ::= "→"