ckecs-architecture-contract

Name: ckecs-architecture-contract
Availability: InStock
Author: Chainkemists

Verify CkFoundation ECS changes against architectural invariants and safety rules.

4|Updated Aug 15, 2023

Search Tags:#architecture #framework #ecs #invariants #unreal engine #ckfoundation

Ready to run

npx skills add https://github.com/chainkemists/CkFoundation --skill ckecs-architecture-contract

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: ckecs-architecture-contract
Source: https://github.com/chainkemists/CkFoundation/tree/main/.claude/skills/ckecs-architecture-contract
Command: npx skills add https://github.com/chainkemists/CkFoundation --skill ckecs-architecture-contract

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides the definitive architectural source of truth for the CkFoundation ECS framework, preventing common integration errors, runtime crashes, and violations of the framework's core design invariants.

Core Features & Use Cases

Architectural Guidance: Explains the two-tier fragment system, handle-gating, and deferred-mutation request contract.
Safety Invariants: Documents critical rules for handle usage, signal binding, and replication application to ensure system stability.
Use Case: When refactoring a feature or debugging a complex interaction, use this skill to verify if your proposed changes preserve the required memory safety, GC ownership, and processor execution order.

Quick Start

Use the ckecs-architecture-contract skill to validate if my proposed change to the timer fragment violates the two-tier reflection boundary or the friend-gated mutation rules.

Frequently Asked Questions about ckecs-architecture-contract

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I verify ECS invariants when refactoring fragments in Unreal Engine?▼

To verify ECS invariants when refactoring fragments in Unreal Engine, validate your proposed changes against the architectural contract governing handle-gating, memory safety, and deterministic mutation ordering to prevent runtime crashes.

What are the architectural rules for handle usage and replication in an ECS framework?▼

Architectural rules for handle usage and replication in an ECS framework define strict safety invariants for friend-gated mutations and signal binding, ensuring proper GC ownership and deterministic processor execution order across the system.

How does deferred-mutation request contract work in CkFoundation ECS?▼

The deferred-mutation request contract in CkFoundation ECS works by enforcing a two-tier fragment system and handle-gating, ensuring mutations are safely deferred and processed in a deterministic order to maintain system-wide stability.

Can I use this architectural contract to debug complex signal binding interactions?▼

Yes, you can use this architectural contract to debug complex signal binding interactions by verifying if your system changes preserve the required safety invariants and proper replication application within the Unreal Engine environment.

Why does my ECS fragment change violate the two-tier reflection boundary?▼

Your ECS fragment change violates the two-tier reflection boundary because it bypasses the friend-gated mutation rules and deferred-mutation request contract, disrupting required memory safety and deterministic mutation ordering.