# The algo records whose force is contract_compatibility

This index as JSON: https://banes-lab.com/json/api/facets/algo/force/contract-compatibility

## Entries

- [Semantic Operation Boundary](https://banes-lab.com/records/algo/semantic-operation-boundary.md): Define required work as semantic operations, defer runtime execution details to adapters, and reject runtime-specific primitives from the portable core contract.
- [Scope Extraction](https://banes-lab.com/records/algo/scope-extraction.md): Determine whether the target is a resource, directory, module, repository, or unknown scope; then extract interfaces, declarations, dependencies, systems, or boundaries appropriate to that scope.
- [Domain Knowledge Base](https://banes-lab.com/records/algo/domain-knowledge-base.md): Store target scope, discovered structure, purposes, dependencies, interfaces, patterns, statistics, timestamp, and evidence sources in a reusable knowledge object.
- [Risk Complexity Reversibility](https://banes-lab.com/records/algo/risk-complexity-reversibility.md): Analyze domain dependencies, side effects, resource count, interface count, dependency patterns, and uncertainty factors to assign risk, complexity, reversibility, and uncertainty.
- [Portable Contract Composition](https://banes-lab.com/records/algo/portable-contract-composition.md): Compose identity, purpose, methodology, domain scope, characteristics, capabilities, phases, validation strategy, constraints, and required outputs into a runtime-neutral agent contract.
- [Adapter Rendering](https://banes-lab.com/records/algo/adapter-rendering.md): Render the portable contract into runtime-specific agent specification, invocation contract, and audit artifacts only through adapter-defined schemas and destinations.
- [Agent Creator Kernel](https://banes-lab.com/records/algo/agent-creator-kernel.md): Load configuration, detect capabilities, check creation history, validate cache, discover domain evidence, build knowledge base, analyze characteristics, extract principles, define phases, compose portable contract, render adapter artifacts, validate outputs, audit, and report.
- [<Agent Generation Concern>](https://banes-lab.com/records/algo/agent-generation-concern.md): <Load context> → <Detect capabilities> → <Check collisions> → <Discover domain evidence> → <Build knowledge> → <Analyze risk> → <Design phases> → <Compose portable contract> → <Render adapters> → <Validate grounding> → <Audit> → <Report>
- [DSL Compliance Loading](https://banes-lab.com/records/algo/dsl-compliance-loading.md): Load grammar, keyword, operator, workflow, and checklist references before workflow generation, then require generated content to follow the declared DSL, naming, handoff, execution, forking, spawning, and capability rules.
- [Four-Dimensional Agent Graph](https://banes-lab.com/records/algo/four-dimensional-agent-graph.md): For each agent, build sequential dependencies, lateral parallel peers, diagonal artifact/data dependencies, and propagation effects including superseded state, propagated contracts, and breakage risks.
- [Template Assembly](https://banes-lab.com/records/algo/template-assembly.md): Assemble frontmatter, workspace config, overview, phase documentation, checklist requirements, orchestration protocol, handoff format, coordination sequence, capability integration, workflow principles, and domain notes into one workflow artifact.
- [Workflow Validation Gate](https://banes-lab.com/records/algo/workflow-validation-gate.md): Validate DSL compliance, workspace discovery, dynamic agent count, execution classification, context configuration, 4D graphs, handoff protocol, hybrid execution, checklist integration, capability integration, template assembly, dynamic paths, uppercase filenames, and agent-oriented content.
- [Workflow Creation Kernel](https://banes-lab.com/records/algo/workflow-creation-kernel.md): Load DSL and orchestration references, configure file recovery and context forking, discover workspace zones and agents, select shared documents, define dynamic agent sequence, classify execution mode, build 4D graphs, define handoff protocol, assemble coordination sequence, integrate checklist and capabilities, generate phase documentation, assemble template, and validate success criteria.
- [<Workflow Orchestration Concern>](https://banes-lab.com/records/algo/workflow-orchestration-concern.md): <Load orchestration grammar> → <Discover workspace config> → <Select shared documents> → <Define agents> → <Classify parallel vs sequential> → <Fork discovery contexts> → <Serialize action phases> → <Build 4D graphs> → <Create handoff protocol> → <Coordinate shared-document refinement> → <Integrate checklist and capabilities> → <Validate template>
- [Anti-Pattern Inversion](https://banes-lab.com/records/algo/anti-pattern-inversion.md): Take any desired architectural principle, invert its invariants, identify the recurring violation shape, model its propagation mechanism, define detection signals, and derive its remediation inverse.
- [Architecture Smell Record](https://banes-lab.com/records/algo/architecture-smell-record.md): Model every smell as a recurring degeneration path with trigger conditions, enabling conditions, detection signals, damage model, remediation inverse, and prevention gate.
- [<Architecture Anti-Pattern>](https://banes-lab.com/records/algo/architecture-anti-pattern.md): <Local shortcut> → <Missing control> → <Repeated usage> → <Implicit dependency> → <Boundary/contract erosion> → <Systemic fragility> → <Expensive remediation>
- [Architectural Relationship Record](https://banes-lab.com/records/algo/architectural-relationship-record.md): Represent every architectural concept as a typed relationship record containing scope, dependencies, reinforcing effects, enabled capabilities, conflicts, tensions, violations, detection signals, metrics, refactor actions, enforcement mechanisms, and severity.
- [Refactor Selection](https://banes-lab.com/records/algo/refactor-selection.md): Given a violation record, select refactor actions from the concept’s refactored_by field, rank actions by severity, dependency closure, blast radius, and expected reinforcement gain.
- [Enforcement Gate](https://banes-lab.com/records/algo/enforcement-gate.md): Translate each concept’s enforced_by field into static checks, contract tests, schema validation, CI gates, policy rules, runtime monitors, review gates, or architecture fitness functions.
- [Contract Compatibility](https://banes-lab.com/records/algo/contract-compatibility.md): For APIs, services, data, schemas, and protocols, validate explicit contracts, preconditions, postconditions, invariants, versioning, backward compatibility, forward compatibility, and interoperability.
- [Self-Description and Discovery](https://banes-lab.com/records/algo/self-description-and-discovery.md): Require components, services, APIs, plugins, and runtime structures to declare metadata, capabilities, contracts, dependencies, configuration, and health so they can be discovered and validated.
- [Runtime Extensibility](https://banes-lab.com/records/algo/runtime-extensibility.md): Detect repeated core modification for variants, define extension points, create plugin contracts, register implementations, discover them dynamically, and isolate failures.
- [Pattern Selection](https://banes-lab.com/records/algo/pattern-selection.md): Select creational, structural, or behavioral patterns based on the problem force: creation variation, interface mismatch, access control, behavior variation, notification, workflow reuse, or coordination complexity.
- [Event and Messaging Consistency](https://banes-lab.com/records/algo/event-and-messaging-consistency.md): For asynchronous systems, validate event contracts, message schemas, idempotent consumers, outbox publication, correlation metadata, ordering guarantees, retry behavior, and dead-letter handling.
- [State and Transaction Safety](https://banes-lab.com/records/algo/state-and-transaction-safety.md): Identify state mutation boundaries, enforce unit-of-work scope, validate invariants, apply concurrency control, guarantee idempotency where retries exist, and isolate side effects.
- [Correctness Verification](https://banes-lab.com/records/algo/correctness-verification.md): Push nondeterminism to boundaries, prefer pure deterministic core logic, validate specifications with static analysis, type checks, property tests, contract tests, formal methods where useful, and reproducible test environments.
- [Metaprogramming Safety](https://banes-lab.com/records/algo/metaprogramming-safety.md): Treat code as data only through schemas, manifests, DSL grammars, reflection contracts, compile-time checks, runtime guards, and generated artifact validation.
- [Streaming Dataflow](https://banes-lab.com/records/algo/streaming-dataflow.md): Process data through forward-only stages, preserve bounded memory, apply backpressure, checkpoint state where needed, and prefer stateless processing unless state is explicitly modeled.
- [Model Architecture Governance](https://banes-lab.com/records/algo/model-lifecycle-governance.md): Register models, prompts, datasets, embeddings, retrieval sources, knowledge graphs, inference contracts, evaluation suites, explainability traces, safety gates, and monitoring policies.
- [Architectural Relationship Algebra](https://banes-lab.com/records/algo/architectural-relationship-algebra.md): <Parse concept records> → <Build relationship graph> → <Classify design force> → <Select applicable concepts> → <Resolve prerequisites> → <Detect violations> → <Measure evidence> → <Choose refactors> → <Enforce gates> → <Govern evolution>
- [Document Truth Alignment](https://banes-lab.com/records/algo/document-truth-alignment.md): 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.
- [Architectural Contract Kernel](https://banes-lab.com/records/algo/architectural-contract-kernel.md): 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.
- [Responsibility Boundary](https://banes-lab.com/records/algo/responsibility-boundary.md): Partition behavior into cohesive units, assign each unit one reason to change, hide internal details, expose only intentional interfaces, and reject cross-boundary leakage.
- [Coupling Control](https://banes-lab.com/records/algo/coupling-control.md): Detect dependency directions, invert dependencies toward abstractions, restrict imports to approved boundaries, and preserve autonomy between modules.
- [Interface Contract](https://banes-lab.com/records/algo/interface-contract.md): Define explicit interfaces with preconditions, postconditions, invariants, error semantics, version rules, and compatibility guarantees before implementation.
- [Substitutability](https://banes-lab.com/records/algo/substitutability.md): 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.
- [Self-Description Manifest](https://banes-lab.com/records/algo/self-description-manifest.md): Require every component to declare identity, capabilities, contracts, dependencies, configuration, health model, and version metadata in a machine-readable manifest.
- [Runtime Discovery](https://banes-lab.com/records/algo/runtime-discovery.md): Discover available components by manifest, convention, registry, or service endpoint; validate discovered candidates against contracts; bind dynamically only after compatibility checks.
- [Extension Point](https://banes-lab.com/records/algo/extension-point.md): Define stable extension contracts, register implementations through IoC or plugin registries, isolate plugin failures, and expose deterministic loading order.
- [Construction Boundary](https://banes-lab.com/records/algo/construction-boundary.md): Hide object creation behind factories, builders, prototypes, or abstract factories so callers depend on creation contracts rather than concrete constructors.
- [Structural Mediation](https://banes-lab.com/records/algo/structural-mediation.md): Insert adapters, facades, proxies, bridges, or decorators where incompatible structure, access control, abstraction separation, or behavior layering is required.
- [Behavioral Dispatch](https://banes-lab.com/records/algo/behavioral-dispatch.md): Externalize variable behavior into strategies, template hooks, observers, or mediators while preserving stable orchestration contracts.
- [Architectural Style Boundary](https://banes-lab.com/records/algo/architectural-style-boundary.md): Select an architectural style by dependency direction, deployment needs, domain size, team topology, and change isolation requirements; enforce style through boundary rules.
- [Error Boundary](https://banes-lab.com/records/algo/error-boundary.md): Detect invalid state early, fail fast for programmer errors, fail safe for recoverable runtime faults, fail secure for security-sensitive failures, and return typed errors.
- [Security Policy](https://banes-lab.com/records/algo/security-policy.md): Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, protect secrets, and enforce policy continuously.
- [Declarative Metaprogramming](https://banes-lab.com/records/algo/declarative-metaprogramming.md): Represent behavior as data, validate the model or DSL, compile or interpret it into runtime behavior, and restrict reflection or code generation behind safety contracts.
- [Streaming Dataflow](https://banes-lab.com/records/algo/architecture-streaming-dataflow.md): Process data sequentially through bounded pipeline stages, preserve forward-only semantics where required, apply backpressure, and keep stages stateless unless state is explicitly modeled.
- [Architecture Selection Meta-Algorithm](https://banes-lab.com/records/algo/architecture-selection-meta-algorithm.md): Given a concern, classify its force type, select the corresponding contract family, compose required invariants, bind implementation patterns, and attach validation gates.
- [Universal Architectural Concern Template](https://banes-lab.com/records/algo/universal-architectural-concern-template.md): For any architectural concern, define its intent, boundary, contract, invariants, allowed variation, forbidden leakage, validation strategy, observability model, and evolution policy.
- [Architectural Contract Algebra](https://banes-lab.com/records/algo/architectural-contract-algebra.md): <Classify architectural force> → <Declare boundary> → <Define contract> → <Choose pattern> → <Bind implementation> → <Verify invariant> → <Observe runtime> → <Govern evolution>
- [Manifest-Driven Documentation](https://banes-lab.com/records/algo/manifest-driven-documentation.md): For a module whose public surface is machine-derivable, make its metadata manifest the single documentation source of truth: authored narrative lives in mandated, shape-validated manifest fields (with self-expanding custom fields), the API surface is collected deterministically from the built type-declarations, one marker-layered document is compiled per module from both, and a governance router runs the context-detection rules on the manifest strings where a manifest governs (rendering each field to its markdown fragment first) and on the document itself where none exists. Beyond the module document, a manifest may declare typed documents — each a form plus concern that routes through the pure location function to a computed path — generated and drift-checked the same way, so the manifest is the single content generator with no separate template mechanism.
- [Consumer Config SSOT](https://banes-lab.com/records/algo/consumer-config-ssot.md): For any reusable package that must stay agnostic of the applications consuming it, hardcode zero consumer-specific truths in package source; declare every consumer-specific value in one consumer-owned config of typed sections, load it through a framework the leaf packages never import, and hand each package only the section it needs through an injection surface — so a package drops into any consumer without a literal about that consumer leaking through its source.
- [Automation Operation Mode](https://banes-lab.com/records/algo/automation-operation-mode.md): Detect operation mode, bind allowed actions, prohibit source mutation outside implementation mode, and emit analysis, design, implementation, or validation artifacts accordingly.
- [Extension Interface Discovery](https://banes-lab.com/records/algo/extension-interface-discovery.md): Search for inheritance, composition, shared method contracts, and shared schema contracts; group similar implementations; infer interface candidates when implementation count exceeds threshold.
- [Dynamic Extension Architecture](https://banes-lab.com/records/algo/dynamic-extension-architecture.md): Infer extension contracts, define discovery conventions, validate discovered implementations against the contract, preserve manual registration fallback, and report discovered, skipped, failed, and manual items.
- [Architecture Validation Before Persistence](https://banes-lab.com/records/algo/architecture-validation-before-persistence.md): Validate generated contracts, registries, resolvers, plans, and entry point updates against schemas and architectural rules before saving or modifying any artifact.
- [Automation Kernel](https://banes-lab.com/records/algo/automation-kernel.md): Load configuration, verify capabilities, initialize knowledge, detect static patterns, classify automation opportunity, analyze conventions, assess scale and performance, design dynamic architecture, optionally implement, validate, update knowledge, and report.
- [<Automation Concern>](https://banes-lab.com/records/algo/automation-concern.md): <Detect static coordination point> → <Classify intentional vs problematic> → <Measure scale pressure> → <Verify convention strength> → <Design dynamic contract> → <Preserve fallback> → <Validate performance and architecture> → <Capture knowledge>
- [Runtime-Agnostic Adapter Boundary](https://banes-lab.com/records/algo/runtime-agnostic-adapter-boundary.md): Express all workflow operations as semantic verbs, delegate runtime-specific mechanics to adapters, and prohibit repository-, shell-, framework-, model-, or path-specific logic from entering the core contract.
- [Operation Mode Gating](https://banes-lab.com/records/algo/operation-mode-gating.md): Detect the requested operation mode, bind permitted capabilities, reject source mutation outside execution mode, and emit only artifacts valid for the current mode.
- [Principle Activation](https://banes-lab.com/records/algo/principle-activation.md): Test each principle in the ontology catalog against the current decision surfaces, mark it applies, uncertain, or not-applicable with a reason, and bind every applied principle to a decision test, a validator, and a severity that later routes its repair.
- [Four-Dimensional Phase Graph](https://banes-lab.com/records/algo/four-dimensional-phase-graph.md): For every phase, model the sequential dependency axis, the lateral independent-peer axis, the diagonal shared-data axis, and the propagation axis carrying superseded state, propagated contracts, and what breaks if the edge is omitted.
- [File-Scoped Fix](https://banes-lab.com/records/algo/file-scoped-fix.md): Read the violating file, analyze the violation type, transform content according to design guidance, write the updated content, and preserve compatibility with verification rules.
- [Console Usage Remediation](https://banes-lab.com/records/algo/console-usage-remediation.md): Replace direct console calls with the approved logging abstraction, preserve severity and message context, and verify no direct console usage remains.
- [Phase-Separated Execution](https://banes-lab.com/records/algo/phase-separated-execution.md): Detect the current workflow phase, bind allowed operations to that phase, reject operations outside the phase contract, and emit only the artifact valid for that phase.
- [Behavioral Self-Test](https://banes-lab.com/records/algo/behavioral-self-test.md): Execute the system’s claimed behaviors against simple positive and negative cases, compare actual output to expected output, and treat mismatch as implementation evidence failure.
- [Safe Arithmetic Contract](https://banes-lab.com/records/algo/safe-arithmetic-contract.md): Check operands before calculation, reject division by zero, reject non-finite results, enforce bounds, and return nullable or typed failure instead of unsafe numeric state.
- [Contract-Based Verification Kernel](https://banes-lab.com/records/algo/contract-based-verification-kernel.md): Declare assumptions, detect phase, verify environment, calibrate tools, execute phase-legal behavior, test adversarially, enforce validation gates, self-verify claims, and emit a typed artifact.
- [<Context Verification Concern>](https://banes-lab.com/records/algo/context-verification-concern.md): <Detect required contract> → <Bind allowed capability> → <Execute bounded operation> → <Validate evidence> → <Emit typed result>
- [Type-Keyed Appearance](https://banes-lab.com/records/algo/type-keyed-appearance.md): In the globals layer, define how every element and component type looks, its size, and its spacing exactly once, keyed only by element tag, `data-el` custom type, and the orthogonal `data-*` axes (`data-variant` paint, `data-size` scale, `data-gap` child rhythm, `data-tone` palette, `data-measure` width); never key appearance by a purpose-class, and let every value be a token.
- [Custom Type Registration](https://banes-lab.com/records/algo/custom-type-registration.md): Extend the stylable element vocabulary beyond the native HTML tag set by registering each semantic type against a base tag and a `data-el` stamp; the registered type becomes a first-class node the globals layer binds one appearance contract to, so a concept no native tag can express — a field-label, an icon, a toast, an entry — is styled by its type, never by a class.
- [Placement Isolation](https://banes-lab.com/records/algo/placement-isolation.md): In the components layer, set only where a component sits — position, offsets, stacking, overlay — keyed by its type, and never its look, size, or spacing, which remain owned by globals.
- [Layer Fitness Enforcement](https://banes-lab.com/records/algo/layer-fitness-enforcement.md): Bind each layer invariant to a machine check — layer order declared once, placement properties barred from globals, class selectors barred from globals, literals barred where a token exists, no horizontal margin, all DOM through the factory, no inline style — run them as hard errors with no warn tier and no inline disables, and gate the push on a clean verdict.
- [CSS Type-Cascade Kernel](https://banes-lab.com/records/algo/css-type-cascade-concern.md): Declare one layer order, hold every value in tokens, key every appearance on a type — native or custom-registered — exactly once in globals, hold placement in components and assembly in app, create all DOM through a factory that stamps types and refuses inline style, and gate the whole contract behind machine fitness functions.
- [Composed Turn Contract](https://banes-lab.com/records/algo/composed-turn-contract.md): Compose a model turn's validation schema and its instruction from one self-registering field registry, projected per mode, so the schema the response is graded against and the instruction the model is given can never drift.
- [Mode Contract Validation](https://banes-lab.com/records/algo/mode-contract-validation.md): Validate the model's response against the loop-selected mode contract and, on a validation miss, drive an error-specific self-healing retry bounded by the contract, so a response is accepted only when it satisfies the schema it is graded against.
- [<Mode-Driven Response Schema>](https://banes-lab.com/records/algo/mode-driven-response-schema.md): Make the model's structured output a mode-driven composed contract — the output mirror of composed input context: per loop-owned mode the schema and instruction are projected from one field registry, the response is validated and self-heals against it, the typed fields are governed, and every turn is persisted as a versioned queryable record — so the output has one source, cannot drift from its instruction, and can be audited.
- [PAG Document Declaration](https://banes-lab.com/records/algo/pag-document-declaration.md): Bind a document to a declared type and its default verb (THIS <TYPE> <VERB> <description>) after the YAML frontmatter and before any node, then declare in the meta block what the document is for, which sources ground which, what it trusts, what it may touch and what it declares outside itself, and how far repair may recurse.
- [PAG Node Decomposition](https://banes-lab.com/records/algo/pag-node-decomposition.md): Group directives into nodes, each one decision on one reasoning axis, headed by its layer, axis, math type and the shape its decision yields, tagged with the substrate stage its artifact comes to be at, and contracted so that its input names the prior node's output or a declared slot, its transform is stated in semantic operations, and its output is the one record the next node reads.
- [PAG Semantic Operation](https://banes-lab.com/records/algo/pag-tool-invocation.md): Name every external effect as one of the semantic operations (discover, read, search, analyze, extract, calculate, compose, validate, persist, execute, request a decision, report) with a uniform WITH / USING parameter clause and an INTO / arrow result binding, so the document names what it does and an adapter binding resolves how, and no host's tool name enters the document.
- [PAG Authoring Kernel](https://banes-lab.com/records/algo/pag-authoring-kernel.md): Compose a PAG document as frontmatter and typed declaration, then a meta block with jurisdiction, then nodes each headed by its layer, axis, math type and yields, contracted to read the prior node's output, and closed by a handoff gate with evidence, population, refusal and the three verdicts, drawing directives from the semantic operations, control flow and structure declarations, and closing with invariant records and a report.
- [Anti-Pattern Classification](https://banes-lab.com/records/algo/anti-pattern-classification.md): Convert duplicated, inconsistent, and architecture-violating findings into anti-pattern records with type, occurrence count, impact, effort, severity, and affected resources.
- [Abstraction Boundary Principle](https://banes-lab.com/records/algo/abstraction-boundary-principle.md): Evaluate each high-priority anti-pattern against boundary principles: universal, invariant, foundational, enforcing, and cognitive-load-reducing.
- [Base-Class Candidate Selection](https://banes-lab.com/records/algo/base-class-candidate-selection.md): Promote an anti-pattern to a base-class candidate only when it satisfies enough boundary principles and applies across a meaningful portion of the semantic domain.
- [Concrete-vs-Abstract Responsibility Split](https://banes-lab.com/records/algo/concrete-vs-abstract-responsibility-split.md): Partition the family's behavior into what is invariant across every member (the topology preserved under substitution) and what varies per member (the novelty); the invariant set becomes the concrete base, the variant set becomes the abstract seam. The concrete/abstract boundary is derived from the evidence, not read off a fixed lifecycle vocabulary — so the split holds for any paradigm, not only OOP class lifecycles.
- [Template Method Lifecycle](https://banes-lab.com/records/algo/template-method-lifecycle.md): Define public lifecycle methods that enforce guard checks, call shared setup or cleanup, invoke subclass hooks, and centralize error handling.
- [Anti-Reintroduction Gate](https://banes-lab.com/records/algo/anti-reintroduction-gate.md): After eliminating an anti-pattern, author or strengthen the custom lint rule that statically forbids its reintroduction and any bypass of the new base, build the rule plugin, and regenerate the rule catalog, so the distilled boundary is enforced by a gate rather than by discipline.
- [<Pattern Distillation Concern>](https://banes-lab.com/records/algo/pattern-distillation-concern.md): <Initialize evidence workspace> → <Measure current architecture> → <Group semantic families> → <Extract behavioral signatures> → <Detect duplicate/inconsistent behavior> → <Score anti-patterns> → <Evaluate abstraction boundary> → <Compose reusable schematic> → <Migrate with rollback> → <Verify old-pattern elimination> → <Record ROI>
- [Name Projection](https://banes-lab.com/records/algo/name-projection.md): Compose the target name from the assigned concern, the subject, and a variant taken only where a collision or a facet requires one, and derive the folder chain from that same concern, so the filename and its placement are one projection rather than two decisions.
- [Technique and Invariant Selection](https://banes-lab.com/records/algo/technique-invariant-selection.md): For each prioritised surface, state the invariant that must hold and select the technique whose reasoning mode matches how that surface is observed, so the test asserts the right property by the right method.