classcore 1.10__tar.gz → 1.11__tar.gz

classcore-1.11/.gitignore

@@ -0,0 +1,7 @@
+.env
+*.so
+.*.swp
+__pycache__/
+bugs/
+build/
+dist/

{classcore-1.10 → classcore-1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classcore
-Version: 1.10
+Version: 1.11
 Summary: Foundational class factories and decorators.
 Project-URL: Homepage, https://github.com/emcd/python-classcore
 Project-URL: Documentation, https://emcd.github.io/python-classcore
@@ -19,11 +19,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development
 Requires-Python: >=3.10
-Requires-Dist: dynadoc
+Requires-Dist: dynadoc~=1.4
 Requires-Dist: typing-extensions
 Description-Content-Type: text/x-rst
 
@@ -283,6 +284,9 @@ Other Projects by This Author 🌟
 * `python-accretive <https://github.com/emcd/python-accretive>`_ (`accretive <https://pypi.org/project/accretive/>`_ on PyPI)
 
   🌌 A Python library package which provides **accretive data structures** - collections which can grow but never shrink.
+* `python-detextive <https://github.com/emcd/python-detextive>`_ (`detextive <https://pypi.org/project/detextive/>`_ on PyPI)
+
+  🕵️ A Python library which provides consolidated text detection capabilities for reliable content analysis. Offers MIME type detection, character set detection, and line separator processing.
 * `python-dynadoc <https://github.com/emcd/python-dynadoc>`_ (`dynadoc <https://pypi.org/project/dynadoc/>`_ on PyPI)
 
   📝 A Python library package which bridges the gap between **rich annotations** and **automatic documentation generation** with configurable renderers and support for reusable fragments.
@@ -295,6 +299,9 @@ Other Projects by This Author 🌟
 * `python-icecream-truck <https://github.com/emcd/python-icecream-truck>`_ (`icecream-truck <https://pypi.org/project/icecream-truck/>`_ on PyPI)
 
   🍦 **Flavorful Debugging** - A Python library which enhances the powerful and well-known ``icecream`` package with flavored traces, configuration hierarchies, customized outputs, ready-made recipes, and more.
+* `python-librovore <https://github.com/emcd/python-librovore>`_ (`librovore <https://pypi.org/project/librovore/>`_ on PyPI)
+
+  🐲 **Documentation Search Engine** - An intelligent documentation search and extraction tool that provides both a command-line interface for humans and an MCP (Model Context Protocol) server for AI agents. Search across Sphinx and MkDocs sites with fuzzy matching, extract clean markdown content, and integrate seamlessly with AI development workflows.
 * `python-mimeogram <https://github.com/emcd/python-mimeogram>`_ (`mimeogram <https://pypi.org/project/mimeogram/>`_ on PyPI)
 
   📨 A command-line tool for **exchanging collections of files with Large Language Models** - bundle multiple files into a single clipboard-ready document while preserving directory structure and metadata... good for code reviews, project sharing, and LLM interactions.

{classcore-1.10 → classcore-1.11}/README.rst

@@ -254,6 +254,9 @@ Other Projects by This Author 🌟
 * `python-accretive <https://github.com/emcd/python-accretive>`_ (`accretive <https://pypi.org/project/accretive/>`_ on PyPI)
 
   🌌 A Python library package which provides **accretive data structures** - collections which can grow but never shrink.
+* `python-detextive <https://github.com/emcd/python-detextive>`_ (`detextive <https://pypi.org/project/detextive/>`_ on PyPI)
+
+  🕵️ A Python library which provides consolidated text detection capabilities for reliable content analysis. Offers MIME type detection, character set detection, and line separator processing.
 * `python-dynadoc <https://github.com/emcd/python-dynadoc>`_ (`dynadoc <https://pypi.org/project/dynadoc/>`_ on PyPI)
 
   📝 A Python library package which bridges the gap between **rich annotations** and **automatic documentation generation** with configurable renderers and support for reusable fragments.
@@ -266,6 +269,9 @@ Other Projects by This Author 🌟
 * `python-icecream-truck <https://github.com/emcd/python-icecream-truck>`_ (`icecream-truck <https://pypi.org/project/icecream-truck/>`_ on PyPI)
 
   🍦 **Flavorful Debugging** - A Python library which enhances the powerful and well-known ``icecream`` package with flavored traces, configuration hierarchies, customized outputs, ready-made recipes, and more.
+* `python-librovore <https://github.com/emcd/python-librovore>`_ (`librovore <https://pypi.org/project/librovore/>`_ on PyPI)
+
+  🐲 **Documentation Search Engine** - An intelligent documentation search and extraction tool that provides both a command-line interface for humans and an MCP (Model Context Protocol) server for AI agents. Search across Sphinx and MkDocs sites with fuzzy matching, extract clean markdown content, and integrate seamlessly with AI development workflows.
 * `python-mimeogram <https://github.com/emcd/python-mimeogram>`_ (`mimeogram <https://pypi.org/project/mimeogram/>`_ on PyPI)
 
   📨 A command-line tool for **exchanging collections of files with Large Language Models** - bundle multiple files into a single clipboard-ready document while preserving directory structure and metadata... good for code reviews, project sharing, and LLM interactions.

{classcore-1.10 → classcore-1.11}/pyproject.toml

@@ -15,7 +15,7 @@ license = 'Apache-2.0'
 readme = { 'file' = 'README.rst', 'content-type' = 'text/x-rst' }
 requires-python = '>= 3.10'
 dependencies = [
-  'dynadoc',
+  'dynadoc ~= 1.4',
   'typing-extensions',
   # --- BEGIN: Injected by Copier ---
   # --- END: Injected by Copier ---
@@ -30,6 +30,7 @@ classifiers = [ # https://pypi.org/classifiers
   'Programming Language :: Python :: 3.11',
   'Programming Language :: Python :: 3.12',
   'Programming Language :: Python :: 3.13',
+  'Programming Language :: Python :: 3.14',
   'Programming Language :: Python :: Implementation :: CPython',
   'Programming Language :: Python :: Implementation :: PyPy',
   # --- END: Injected by Copier ---
@@ -93,12 +94,12 @@ strict-naming = false
 python = '3.10'
 [tool.hatch.envs.develop]
 description = ''' Development environment. '''
+builder = true
 dependencies = [
-  'Jinja2',
   'coverage[toml]',
   'furo',
   'isort',
-  'packaging',
+  'myst-parser',
   'pre-commit',
   'pyright',
   'pytest',
@@ -128,10 +129,10 @@ docsgen = [
 ]
 linters = [
   """ruff check --quiet sources documentation tests""",
+  # """vibelinter check""",
   # --- BEGIN: Injected by Copier ---
   # --- END: Injected by Copier ---
   """isort --check-only --diff sources tests""",
-  """vulture""",
   """pyright sources""",
 ]
 packagers = [
@@ -173,7 +174,8 @@ python = [
     '3.11',
     '3.12',
     '3.13',
-    'pypy3.10',
+    '3.14',
+    'pypy3.11',
 ]
 # [tool.hatch.metadata]
 # allow-direct-references = true
@@ -348,6 +350,10 @@ directory = 'repair'
 name = 'Repairs'
 showcontent = true
 
+[tool.vibelinter]
+context = 3
+exclude_paths = [ '.auxiliary/**', '.venv/**', 'tests/**',  ]
+
 [tool.vulture]
 paths = [ '.auxiliary/configuration/vulturefood.py', 'sources' ]
 min_confidence = 60

classcore-1.11/sources/classcore/README.md

@@ -0,0 +1,452 @@
+# classcore
+
+Classcore is a foundational library for creating classes with customized
+behaviors, particularly immutability and concealment. The library operates at
+the metaclass level to provide composable, inheritable behaviors while
+maintaining compatibility with standard Python features like dataclasses and
+protocols.
+
+## Architectural Goals
+
+**Composability**
+   Enable incremental addition of class behaviors through decorators,
+   metaclasses, and inheritance without conflicts or unexpected interactions.
+
+**Transparency**
+   Work seamlessly with existing Python features (dataclasses, protocols,
+   ABCs) and tools (type checkers, IDEs).
+
+**Customizability**
+   Provide extension points at every layer for users to adapt behaviors to
+   specific needs through verifiers, hooks, and core function replacements.
+
+**Performance**
+   Minimize runtime overhead through strategic caching and lazy evaluation
+   while centralizing import costs at package initialization.
+
+## High-Level Architecture
+
+The system follows a layered architecture with clear separation of concerns:
+
+### Core Factory Layer
+
+Location: `factories.py`
+
+Produces metaclass components with customizable hooks:
+
+- `produce_class_constructor`: Creates `__new__` implementations with
+  preprocessor and postprocessor hooks
+- `produce_class_initializer`: Creates `__init__` implementations with
+  completer hooks
+
+These factories enable the construction of metaclasses that can intercept and
+augment class creation at multiple lifecycle points.
+
+### Decorator Layer
+
+Location: `decorators.py`
+
+Manages class decoration and replacement:
+
+- `apply_decorators`: Applies decorator sequences while handling class
+  replacements
+- `decoration_by`: Composes multiple decorators with preparation hooks
+- `produce_class_construction_decorator`: Wraps constructor logic into
+  metaclass `__new__`
+- `produce_class_initialization_decorator`: Wraps initializer logic into
+  metaclass `__init__`
+
+Critical feature: Repairs class closures when decorators replace classes
+(e.g., `dataclass(slots=True)`), ensuring `super()` continues to function
+correctly.
+
+### Behavior Layer
+
+Location: `standard/behaviors.py`
+
+Implements immutability and concealment enforcement:
+
+- Attribute assignment control with selective mutability
+- Attribute deletion control
+- Attribute visibility filtering for `dir()`
+- Verifier system supporting names, regexes, and predicates
+
+The verifier system allows fine-grained control: specify mutable attributes by
+name, pattern, or custom predicate functions.
+
+### Standard Layer
+
+Location: `standard/`
+
+Pre-configured implementations for common use cases:
+
+**Base Classes:**
+- `Object`: Standard class with immutability and concealment
+- `DataclassObject`: Automatic dataclass conversion with standard behaviors
+- `ProtocolObject`: Protocol class with immutability and concealment
+- Variants for selective mutability (`ObjectMutable`, etc.)
+
+**Metaclasses:**
+- `Class`: Metaclass for standard classes
+- `Dataclass`: Metaclass that auto-applies dataclass decorator
+- `Protocol`: Metaclass for protocol classes
+- Mutable variants of each
+
+**Decorators:**
+- `class_with_standard_behaviors`: Add behaviors to existing classes
+- `dataclass_with_standard_behaviors`: Dataclass creation with behaviors
+- `protocol_with_standard_behaviors`: Protocol creation with behaviors
+
+**Module Utilities:**
+- `reclassify_module`: Apply immutability and concealment to module objects
+- `finalize_module`: Complete module initialization with standard behaviors
+
+### Utility Layer
+
+Location: `utilities.py`
+
+Provides essential operations for metaclass machinery:
+
+- `mangle_name`: Creates unique attribute names using SHA-256 hashing to
+  avoid inheritance collisions
+- `getattr0/setattr0/delattr0`: Access mangled attributes while respecting
+  `__slots__`
+- `repair_class_reproduction`: Fixes closure cells when decorators replace
+  classes (CPython/PyPy-specific)
+- `describe_object`: Generates human-readable object descriptions for error
+  messages
+
+## Data Flow
+
+### Class Creation Flow
+
+1. User defines class with standard metaclass or inherits from standard base
+2. Metaclass `__new__` invoked via `produce_class_constructor`
+3. Preprocessors modify bases, namespace, arguments, decorators
+4. Superclass `__new__` creates initial class object
+5. Progress flag prevents recursive processing
+6. Postprocessors execute (e.g., adding behavior configurations)
+7. Decorators applied via `apply_decorators`
+8. If decorator replaces class, closures repaired
+9. Metaclass `__init__` invoked via `produce_class_initializer`
+10. Completers execute (e.g., freezing behaviors)
+11. Progress flag cleared
+12. Fully initialized class returned
+
+### Attribute Access Flow (Instances)
+
+**Assignment (`obj.attr = value`):**
+1. `__setattr__` intercepted by assigner core function
+2. Check for immutability behavior flag
+3. If immutable, verify against mutables (names, regexes, predicates)
+4. If allowed, delegate to ligation (super or core override)
+5. If denied, raise `AttributeImmutability` error
+
+**Visibility (`dir(obj)`):**
+1. `__dir__` intercepted by surveyor core function
+2. Collect all attributes from object and class hierarchy
+3. Check visibility verifiers (names, regexes, predicates)
+4. Filter attributes based on verifiers
+5. Return filtered set
+
+## Key Architectural Patterns
+
+### Factory Pattern
+
+Metaclass components are produced by factory functions rather than fixed
+inheritance hierarchies. This enables composition of behaviors and runtime
+customization of class creation logic.
+
+### Decorator Composition
+
+Multiple decorators can be applied in sequence, with automatic handling of
+class replacements. The `decoration_by` function enables declarative
+composition of decorator stacks.
+
+### Hook-Based Extension
+
+Every critical point in the class lifecycle offers hooks:
+
+- Preprocessors: Modify class construction inputs
+- Postprocessors: Augment constructed classes
+- Completers: Finalize initialized classes
+- Preparers: Adjust decorator lists before application
+
+### Verifier Pattern
+
+Behavior exclusions (mutability, visibility) use a uniform verifier interface:
+
+- Literal `'*'`: Allow all
+- Sequence of strings: Exact name matches
+- Sequence of `re.Pattern`: Regex matches
+- Sequence of callables: Predicate functions
+
+This provides flexible, user-customizable behavior rules.
+
+### Core Function Replacement
+
+Critical behaviors (assignment, deletion, visibility) can be replaced entirely
+by providing alternative "core" functions. This enables deep customization
+without subclassing.
+
+## Integration Points
+
+### Dataclasses
+
+Standard metaclasses automatically apply `dataclasses.dataclass` during
+class construction, with configurability for `frozen`, `slots`, etc. The
+decorator application system ensures proper handling of the class replacement
+that occurs with `slots=True`.
+
+### Protocols
+
+Standard protocol classes combine `typing.Protocol` with immutability and
+concealment. Special handling for ABC-related mutable attributes
+(`_abc_cache`, `_abc_registry`, etc.) ensures protocol functionality.
+
+### Type Checkers
+
+Metaclasses use `@dataclass_transform` decorator to signal dataclass
+behavior to type checkers. This enables proper type inference and checking
+for classes produced by standard metaclasses.
+
+### Module Objects
+
+Module reclassification applies class-level behaviors to module objects,
+enabling immutable, concealed module namespaces for API control.
+
+## Dependencies
+
+### External Dependencies
+
+The library depends on standard library modules only:
+
+- `dataclasses`: Automatic dataclass generation
+- `functools`: Decorator utilities and partials
+- `hashlib`: Attribute name mangling (SHA-256)
+- `inspect`: Class and function introspection
+- `platform`: Python implementation detection for platform-specific repairs
+- `re`: Regular expression support for verifiers
+- `typing`: Type hints and protocol support
+- `collections.abc`: Abstract base classes
+
+### Internal Dependencies
+
+- `dynadoc`: Documentation generation with fragment interpolation
+- `frigid`: Immutable data structures for internal use
+- `falsifier`: Base classes for falsey objects
+
+## Extension Points
+
+Users can extend the library at multiple levels:
+
+**Decorator Level**
+   Create custom class decorators and compose with `decoration_by`.
+
+**Metaclass Level**
+   Build custom metaclasses using factory functions with custom hooks.
+
+**Behavior Level**
+   Replace core functions for assignment, deletion, visibility, or error
+   provision.
+
+**Verifier Level**
+   Implement custom predicate functions for mutability/visibility rules.
+
+**Hook Level**
+   Provide preprocessors, postprocessors, completers, or preparers for
+   lifecycle customization.
+
+## Filesystem Organization
+
+### Root Directory
+
+```
+python-classcore/
+├── LICENSE.txt              # Project license
+├── README.rst               # Project overview and quick start
+├── pyproject.toml           # Python packaging and tool configuration
+├── documentation/           # Sphinx documentation source
+├── sources/                 # All source code
+├── tests/                   # Test suites
+└── .auxiliary/              # Development workspace
+```
+
+### Package Structure
+
+```
+sources/
+└── classcore/                   # Main Python package
+    ├── __/                      # Centralized import hub
+    │   ├── __init__.py          # Re-exports core utilities
+    │   ├── imports.py           # External library imports
+    │   ├── nomina.py            # Naming constants
+    │   └── doctab.py            # Documentation table fragments
+    ├── __init__.py              # Package entry point
+    ├── py.typed                 # Type checking marker
+    ├── decorators.py            # Class decorator utilities
+    ├── exceptions.py            # Package exception classes
+    ├── factories.py             # Metaclass factory functions
+    ├── nomina.py                # Public naming types and utilities
+    ├── utilities.py             # Class manipulation utilities
+    └── standard/                # Standard behaviors subpackage
+        ├── __.py                # Inherits parent imports
+        ├── __init__.py          # Subpackage entry point
+        ├── behaviors.py         # Immutability and concealment logic
+        ├── classes.py           # Standard metaclasses and base classes
+        ├── decorators.py        # Standard class decorators
+        ├── dynadoc.py           # Documentation configuration
+        ├── modules.py           # Module reclassification utilities
+        └── nomina.py            # Standard-specific naming types
+```
+
+### Module Responsibilities
+
+#### Core Package (`sources/classcore/`)
+
+`__/__init__.py`
+: Re-exports commonly used imports from `imports.py` for convenient access
+  via `from . import __` in all package modules.
+
+`__/imports.py`
+: Centralizes all external library imports. Provides abbreviated aliases for
+  frequently used types and modules (e.g., `cabc` for
+  `collections.abc`, `typx` for `typing`).
+
+`__/nomina.py`
+: Package-specific naming constants and utilities used internally by the
+  `__` import hub.
+
+`__/doctab.py`
+: Documentation table with reusable fragments for dynadoc interpolation.
+
+`__init__.py`
+: Package entry point. Exports public API, applies standard behaviors to
+  package module, sets version.
+
+`decorators.py`
+: Class decorator utilities:
+
+  - `apply_decorators`: Apply decorator sequences with class replacement
+    handling
+  - `decoration_by`: Compose multiple decorators
+  - `produce_class_construction_decorator`: Create metaclass `__new__`
+    decorators
+  - `produce_class_initialization_decorator`: Create metaclass `__init__`
+    decorators
+
+`exceptions.py`
+: Package exception hierarchy. All exceptions use standard behaviors
+  (immutability and concealment) themselves.
+
+`factories.py`
+: Metaclass component factories:
+
+  - `produce_class_constructor`: Generate customizable `__new__` with
+    hooks
+  - `produce_class_initializer`: Generate customizable `__init__` with
+    hooks
+
+`nomina.py`
+: Public naming types, type aliases, and protocols used throughout the
+  package. Defines interfaces for hooks, verifiers, and core functions.
+
+`utilities.py`
+: Class manipulation utilities:
+
+  - `mangle_name`: Create unique attribute names
+  - `getattr0/setattr0/delattr0`: Mangled attribute access
+  - `repair_class_reproduction`: Fix closures after class replacement
+  - `describe_object`: Generate error message descriptions
+
+#### Standard Subpackage (`sources/classcore/standard/`)
+
+`__.py`
+: Inherits all imports from parent `__` via `from ..__ import *`.
+  Demonstrates the cascading import pattern for subpackages.
+
+`__init__.py`
+: Subpackage entry point. Exports all standard classes, decorators, and
+  utilities. Applies standard behaviors to subpackage module.
+
+`behaviors.py`
+: Core implementation of standard behaviors:
+
+  - `assign_attribute_if_mutable`: Conditional attribute assignment
+  - `delete_attribute_if_mutable`: Conditional attribute deletion
+  - `survey_visible_attributes`: Filter attributes for `dir()`
+  - Verifier processing for names, regexes, and predicates
+
+`classes.py`
+: Standard metaclasses and base classes:
+
+  - `Class` / `Object`: Standard class with full behaviors
+  - `Dataclass` / `DataclassObject`: Auto-dataclass with behaviors
+  - `Protocol` / `ProtocolObject`: Protocol with behaviors
+  - Mutable variants for each
+
+`decorators.py`
+: Standard class decorators:
+
+  - `class_with_standard_behaviors`: Apply behaviors to existing class
+  - `dataclass_with_standard_behaviors`: Create dataclass with behaviors
+  - `protocol_with_standard_behaviors`: Create protocol with behaviors
+  - `class_factory`: Generic factory for creating custom metaclasses
+
+`dynadoc.py`
+: Dynadoc configuration for standard behaviors. Provides documentation
+  fragments that describe behaviors automatically applied to classes.
+
+`modules.py`
+: Module reclassification utilities:
+
+  - `reclassify_module`: Apply behaviors to single module
+  - `finalize_module`: Complete module initialization (used by package)
+
+`nomina.py`
+: Standard-specific naming types and constants. Defines behavior labels
+  and attribute naming functions.
+
+All package modules use the standard `__` import pattern as documented
+in the common architecture guide.
+
+### Component Integration
+
+#### Import Hub Usage
+
+All modules access common dependencies through the `__` import hub:
+
+```python
+# In any module at sources/classcore/
+from . import __
+
+# Use abbreviated imports
+def example( items: __.cabc.Sequence[ str ] ) -> __.typx.Any:
+    return __.funct.partial( some_function, items )
+```
+
+This pattern:
+
+- Eliminates redundant import statements
+- Provides consistent naming across modules
+- Centralizes import changes to `__/imports.py`
+- Reduces module namespace pollution
+
+#### Subpackage Extension
+
+The `standard/` subpackage demonstrates the cascading import pattern.
+Its `__.py` inherits parent imports and can add specialized dependencies:
+
+```python
+# sources/classcore/standard/__.py
+from ..__ import *              # Inherit all parent imports
+from ..exceptions import *      # Add package exceptions
+```
+
+Modules in `standard/` use the same import pattern but gain access to both
+parent and subpackage-specific imports.
+
+## Sister Projects
+
+- **[frigid](https://github.com/emcd/python-frigid)** — Fully immutable data structures. Like classcore, but values cannot be added or changed after creation. Useful for configuration objects, constants, and thread-safe data carriers.
+- **[accretive](https://github.com/emcd/python-accretive)** — Grow-only data structures. Values can be added (never modified or removed) after creation. Useful for registries, plugin systems, and sticky-state configurations.

{classcore-1.10 → classcore-1.11}/sources/classcore/__/imports.py

@@ -37,3 +37,6 @@ import dynadoc as           ddoc
 import typing_extensions as typx
 # --- BEGIN: Injected by Copier ---
 # --- END: Injected by Copier ---
+
+# --- BEGIN: Injected by Copier ---
+# --- END: Injected by Copier ---

{classcore-1.10 → classcore-1.11}/sources/classcore/__init__.py

@@ -62,7 +62,7 @@ from .factories import *
 
 
 __version__: __.typx.Annotated[ str, __.ddoc.Visibilities.Reveal ]
-__version__ = '1.10'
+__version__ = '1.11'
 
 
 standard.finalize_module(

{classcore-1.10 → classcore-1.11}/sources/classcore/nomina.py

@@ -64,6 +64,40 @@ DecoratorsMutable: __.typx.TypeAlias = __.typx.Annotated[
         ''' ),
 ]
 
+ClassDecorator: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Callable[ [ type[ __.U ] ], type[ __.U ] ],
+    __.ddoc.Doc(
+        ''' Class decorator.
+
+            Takes class argument and returns class.
+        ''' ),
+]
+ClassDecorators: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Sequence[ ClassDecorator[ __.U ] ],
+    __.ddoc.Doc(
+        ''' Sequence of class decorators.
+
+            Each element takes a class argument and returns a class.
+        ''' ),
+]
+ClassDecoratorFactory: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Callable[ ..., ClassDecorator[ __.U ] ],
+    __.ddoc.Doc(
+        ''' Factory that produces class decorators.
+
+            Returns a class decorator when called.
+        ''' ),
+]
+ModuleReclassifier: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Callable[ [ __.cabc.Mapping[ str, __.typx.Any ] ], None ],
+    __.ddoc.Doc(
+        ''' Reclassifies module attributes.
+
+            Takes a mapping of attribute names to values and applies
+            reclassification (e.g., immutability and concealment).
+        ''' ),
+]
+
 DecorationPreparer: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ type[ __.U ], DecoratorsMutable[ __.U ] ], None ],
     __.ddoc.Doc(

classcore-1.11/sources/classcore/standard/README.md

@@ -0,0 +1,202 @@
+# classcore.standard
+
+The `standard` subpackage provides pre-configured implementations of
+classcore's behaviors for common use cases. It includes base classes,
+metaclasses, decorators, and module utilities that combine immutability and
+concealment with standard Python features like dataclasses and protocols.
+
+## Base Classes
+
+### `Object`
+
+Standard class with full immutability and concealment behaviors. Instances
+have immutable attributes and concealed internal attributes.
+
+```python
+from classcore.standard import Object
+
+class Point(Object):
+    x: float
+    y: float
+```
+
+### `DataclassObject`
+
+Automatic dataclass conversion with standard behaviors. Unlike
+`dataclass(frozen=True)`, attributes can still be manipulated via
+`__post_init__`.
+
+```python
+from dataclasses import field
+from math import sqrt
+from classcore.standard import DataclassObject
+
+class Point2d(DataclassObject):
+    x: float
+    y: float
+    hypotenuse: float = field(init=False)
+    def __post_init__(self) -> None:
+        x, y = self.x, self.y
+        self.hypotenuse = sqrt(x*x + y*y)
+```
+
+### `ProtocolObject`
+
+Protocol class with immutability and concealment. Combines `typing.Protocol`
+with standard behaviors. Immutability and concealment are inherited by
+subclassed implementations.
+
+### Mutable Variants
+
+- `ObjectMutable`: Object with concealment only (no immutability)
+- `DataclassObjectMutable`: DataclassObject with concealment only
+- `ProtocolObjectMutable`: ProtocolObject with concealment only
+
+## Metaclasses
+
+### `Class`
+
+Metaclass for standard classes. Provides immutability and concealment to
+any class that uses this metaclass.
+
+### `Dataclass`
+
+Metaclass that automatically applies `dataclasses.dataclass` during class
+construction. Configurable for `frozen`, `slots`, etc.
+
+### `Protocol`
+
+Metaclass for protocol classes. Combines `typing.Protocol` with standard
+behaviors.
+
+### Mutable Variants
+
+- `ClassMutable`: Metaclass with concealment only
+- `DataclassMutable`: Dataclass metaclass with concealment only
+- `ProtocolMutable`: Protocol metaclass with concealment only
+
+## Decorators
+
+### `class_with_standard_behaviors`
+
+Apply standard behaviors to an existing class.
+
+```python
+from classcore.standard import class_with_standard_behaviors
+
+@class_with_standard_behaviors()
+class ExistingClass:
+    x: int = 10
+```
+
+### `dataclass_with_standard_behaviors`
+
+Create a dataclass with standard behaviors applied.
+
+```python
+from classcore.standard import dataclass_with_standard_behaviors
+
+@dataclass_with_standard_behaviors()
+class Point:
+    x: float
+    y: float
+```
+
+### `protocol_with_standard_behaviors`
+
+Create a protocol with standard behaviors applied.
+
+### `class_factory`
+
+Generic factory for creating custom metaclasses with standard behaviors.
+
+## Module Utilities
+
+### `reclassify_module`
+
+Apply immutability and concealment to a single module object.
+
+```python
+from classcore.standard import reclassify_module
+
+reclassify_module(__name__)
+```
+
+### `finalize_module`
+
+Complete module initialization with standard behaviors. Used internally by
+the package to apply behaviors to all subpackage modules.
+
+### `reclassify_modules` (deprecated)
+
+Apply behaviors to entire packages recursively. Deprecated in favor of
+`finalize_module` for individual module control.
+
+## Behavior System
+
+### Immutability
+
+Attributes are immutable by default. Assignment attempts raise
+`AttributeImmutability`. Deletion attempts raise
+`AttributeDeletionImmutability`.
+
+### Concealment
+
+Internal attributes are concealed from `dir()` output. Only public
+attributes and explicitly visible attributes are shown.
+
+### Selective Mutability
+
+Specify mutable attributes using verifiers:
+
+- **Names**: Exact string matches
+- **Regexes**: Regular expression patterns
+- **Predicates**: Custom callable functions
+
+```python
+from classcore.standard import ObjectMutableByNames
+
+class Config(ObjectMutableByNames, mutable_names=('debug', 'verbose')):
+    debug: bool = False
+    verbose: bool = False
+    name: str = 'default'
+```
+
+### Verifier Interface
+
+Behavior exclusions use a uniform verifier interface:
+
+- Literal `'*'`: Allow all
+- Sequence of strings: Exact name matches
+- Sequence of `re.Pattern`: Regex matches
+- Sequence of callables: Predicate functions
+
+## Integration with Dataclasses
+
+Standard metaclasses automatically apply `dataclasses.dataclass` during
+class construction. The decorator application system ensures proper handling
+of the class replacement that occurs with `slots=True`.
+
+Key features:
+- `__post_init__` can still modify attributes (unlike `frozen=True`)
+- Slot classes are properly supported
+- Type checkers recognize the dataclass transform
+
+## Integration with Protocols
+
+Standard protocol classes combine `typing.Protocol` with immutability and
+concealment. Special handling for ABC-related mutable attributes
+(`_abc_cache`, `_abc_registry`, etc.) ensures protocol functionality.
+
+## Import Pattern
+
+The standard subpackage uses the cascading import pattern:
+
+```python
+# sources/classcore/standard/__.py
+from ..__ import *              # Inherit all parent imports
+from ..exceptions import *      # Add package exceptions
+```
+
+Modules in `standard/` use the same `__` import pattern as the parent
+package, gaining access to both parent and subpackage-specific imports.

{classcore-1.10 → classcore-1.11}/sources/classcore/standard/classes.py

@@ -27,6 +27,12 @@ from . import dynadoc as _dynadoc
 from . import nomina as _nomina
 
 
+_abc_class_mutables = (
+    '_abc_cache',
+    '_abc_negative_cache',
+    '_abc_negative_cache_version',
+    '_abc_registry',
+)
 _dynadoc_configuration = (
     _dynadoc.produce_dynadoc_configuration( table = __.fragments ) )
 _class_factory = __.funct.partial(
@@ -208,12 +214,7 @@ class DataclassObjectMutable( metaclass = DataclassMutable ):
 class Protocol(
     __.typx.Protocol,
     metaclass = ProtocolClass,
-    class_mutables = (
-        '_abc_cache',
-        '_abc_negative_cache',
-        '_abc_negative_cache_version',
-        '_abc_registry',
-    ),
+    class_mutables = _abc_class_mutables,
 ):
     ''' Standard base protocol class. '''
 
@@ -226,12 +227,7 @@ class Protocol(
 class ProtocolMutable(
     __.typx.Protocol,
     metaclass = ProtocolClass,
-    class_mutables = (
-        '_abc_cache',
-        '_abc_negative_cache',
-        '_abc_negative_cache_version',
-        '_abc_registry',
-    ),
+    class_mutables = _abc_class_mutables,
     instances_mutables = '*',
 ):
     ''' Base protocol class with mutable instance attributes. '''
@@ -245,12 +241,7 @@ class ProtocolMutable(
 class DataclassProtocol(
     __.typx.Protocol,
     metaclass = ProtocolDataclass,
-    class_mutables = (
-        '_abc_cache',
-        '_abc_negative_cache',
-        '_abc_negative_cache_version',
-        '_abc_registry',
-    ),
+    class_mutables = _abc_class_mutables,
 ):
     ''' Standard base protocol dataclass. '''
 
@@ -263,12 +254,7 @@ class DataclassProtocol(
 class DataclassProtocolMutable(
     __.typx.Protocol,
     metaclass = ProtocolDataclassMutable,
-    class_mutables = (
-        '_abc_cache',
-        '_abc_negative_cache',
-        '_abc_negative_cache_version',
-        '_abc_registry',
-    ),
+    class_mutables = _abc_class_mutables,
 ):
     ''' Base protocol dataclass with mutable instance attributes. '''
 

{classcore-1.10 → classcore-1.11}/sources/classcore/standard/nomina.py

@@ -109,7 +109,6 @@ class ClassPreparer( __.typx.Protocol ):
 
 
 DynadocConfiguration: __.typx.TypeAlias = __.cabc.Mapping[ str, __.typx.Any ]
-# TODO: Use argument type aliases from 'dynadoc' package.
 DynadocContextArgument: __.typx.TypeAlias = __.typx.Annotated[
     __.ddoc.Context,
     __.ddoc.Doc(

classcore-1.10/.gitignore

@@ -1,15 +0,0 @@
-.env
-.claude
-.gemini
-.mcp.json
-.opencode
-.*.swp
-AGENTS.md
-CLAUDE.md
-CONVENTIONS.md
-GEMINI.md
-opencode.jsonc
-__pycache__/
-bugs/
-build/
-dist/