# RFC-0001A — Orbit Application Runtime Extraction Register ## Status Status: ADOPTED Specification Version: 1.0 Implementation Status: ✔ Certified Reference Consumer: ZeroTrust Atlas Next RFC: RFC-0001B — Orbit Application Framework Foundation **IMPLEMENTATION AUDIT** ## Source Implementation - **Product:** ZeroTrust Atlas - **Repository:** `/opt/zerotrust-geocloud` - **Source branch:** `feature/bm-2.02-product-surface` - **Audit branch:** `feature/orbit-rfc-0001a-runtime-extraction-audit` - **Reference milestone:** `BM-2.11A.01` - **Reference commit:** `ca26e0d` ## Purpose This register identifies the reusable application-runtime implementation proven within ZeroTrust Atlas and defines the boundary between Orbit-Core framework code and Atlas product code. RFC-0001 will not be considered implemented by prose alone. Its reusable implementation must be: 1. extracted into a versioned Orbit-Core package; 2. installed by Atlas as an external dependency; 3. certified inside Atlas; 4. published through the Orbit-Core package infrastructure; and 5. adopted by a second ZeroTrust product. The purpose of RFC-0001A is to establish the extraction boundary before any reusable implementation is moved out of Atlas. ## Governing Principle > An Orbit RFC is published as a versioned contract, tested implementation, reference integration, reproducible release, and adoption path—not merely as a document. Atlas is the first reference implementation. Orbit-Core will become the permanent owner and publisher of the reusable runtime. ## Ownership Classifications ### ORBIT-CORE Implementation that is product-neutral and should be owned, versioned, tested, certified, and published by Orbit-Core. Examples include: - generic application contracts; - reusable immutable value objects; - generic workspace resolution; - generic navigation rendering; - document identity policies; - application-frame composition; - shell containment rules; - reusable CSS contracts; - package certification utilities. ### ATLAS Geospatial product behavior, terminology, data, routes, workflows, runtime services, and user interfaces that must remain inside ZeroTrust Atlas. Examples include: - maps and spatial viewports; - datasets and layers; - dataset publishing; - catalogue behavior; - geospatial observatory data; - spatial infrastructure; - Atlas missions; - Atlas routes; - Atlas workspace declarations. ### MIXED A file that currently contains both reusable framework behavior and Atlas-specific behavior. A mixed file must not be moved wholesale. Its generic and product-specific responsibilities must be separated during extraction. ### COMPATIBILITY A temporary adapter that allows existing Atlas code to continue functioning while the product migrates to the Orbit-Core package. Compatibility code must have: - an explicit purpose; - an identified removal condition; - test coverage; - no permanent architectural authority. ### EVIDENCE Tests, audits, baselines, certifications, migration records, and validation artifacts that prove architectural or rendering invariants. Evidence may remain product-specific, become parameterized for reuse, or be divided between package certification and consumer certification. ## Proposed Package - **Package name:** `orbit/application-runtime` - **Distribution mechanism:** Composer - **Package type:** Laravel-compatible PHP library - **Initial development version:** `0.1.0` - **First stable version:** `1.0.0` - **Reference consumer:** ZeroTrust Atlas - **Required second consumer:** Aloqu or WireShield - **Primary publisher:** Orbit-Core - **Release authority:** Orbit-Core engineering team ## Reusable Architecture ```text Orbit Application └── Application Frame ├── Application Identity ├── Primary Navigation Authority ├── Document Authority ├── Workspace Identity ├── Workspace Header ├── Toolbar Region ├── Workspace Host ├── Status Region └── Product Surface Slot ``` The Application Frame is the reusable host. The product surface is supplied by the consuming product. Examples: ```text Orbit Application Runtime ├── Atlas Map Surface ├── Aloqu Communications Surface ├── WireShield VPN Surface ├── VoIP Shield Security Surface ├── Hostiva Cloud Surface ├── RecoveryOS Recovery Surface ├── DarkRealm DNS Surface └── Valashi Property Surface ``` ## Dependency Direction The permanent dependency direction must be: ```text Orbit-Core repository │ │ publishes a versioned package ▼ Product repository │ │ installs the package ▼ Product application imports the canonical implementation │ ▼ Product supplies product-specific configuration and content ``` Products must not copy framework files from Orbit-Core. Products must install and version Orbit-Core packages through a supported package manager. For Atlas and other Laravel applications, the first supported distribution mechanism is Composer. ## Mandatory Runtime Invariants 1. An Orbit application renders exactly one application-level primary navigation authority. 2. Workflow navigation may coexist with application navigation but must remain scoped to its workflow. 3. Product pages must not independently render application navigation. 4. Application identity must be registry-driven. 5. Workspace identity must be registry-driven. 6. Document identity must derive from canonical application and workspace definitions. 7. The Application Frame owns outer shell and document composition. 8. Product surfaces must enter the runtime through explicit composition slots. 9. Workspace scrolling and overflow ownership must be deterministic. 10. Generic implementation must not contain Atlas-specific routes, geospatial terminology, or product behavior. 11. Product configuration must not redefine generic runtime behavior. 12. Every published runtime version must include automated package certification. 13. Every consuming product must include consumer integration certification. 14. Compatibility adapters must not become competing authorities. 15. Package releases must use semantic versioning. 16. A stable RFC implementation must have at least one reference consumer. 17. General reuse must be demonstrated by adoption in a second product. ## Proven Atlas Achievements The current Atlas implementation has already proven the following reusable capabilities. ### Canonical Application Frame Atlas pages compose through one canonical Application Frame rather than defining independent page shells. The frame provides: - application identity; - primary navigation; - document composition; - workspace context; - content slots; - toolbar regions; - status regions; - outer layout authority. ### Single Navigation Authority All primary `/atlas` pages now render exactly one canonical application navigation. The implementation distinguishes: - application navigation; - workflow navigation; - local content navigation. Publishing retains its workflow steps without rendering a second application navigation bar. ### Registry-Driven Workspace Identity Atlas workspaces are described through immutable workspace records and resolved through a central registry. The registry supplies: - workspace code; - navigation code; - title; - description; - route identity; - external-state behavior; - runtime configuration. ### Canonical Document Authority Document and workspace identity are no longer assembled independently by every page. The Application Frame and workspace registration establish consistent document composition. ### Desktop Shell and Containment Atlas has implemented deterministic shell behavior for: - viewport height; - nested workspace regions; - panel containment; - scroll ownership; - overflow boundaries; - content shrinking; - desktop-style application presentation. ### Composition Certification Atlas does not merely test route availability. It certifies: - canonical frame composition; - workspace registration; - rendered navigation count; - absence of legacy navigation; - document authority; - shell containment; - scrolling contracts; - workflow navigation preservation; - product-surface composition. ### Structural Auditing The current audit verifies that: - the Application Frame is the navigation authority; - every primary surface reaches one Application Frame; - legacy Experience Bar includes are absent; - page-level Experience Bar properties are absent; - pages do not directly render application navigation; - compatibility adapters delegate correctly; - Publishing workflow navigation remains present. ## Extraction Register | Current Atlas implementation | Classification | Current responsibility | Proposed Orbit-Core destination | Atlas-specific dependency | Required extraction action | Removal condition | |---|---|---|---|---|---|---| | `resources/views/components/atlas/application-frame.blade.php` | MIXED | Canonical shell, document composition, navigation host, workspace host and product slots | `packages/application-runtime/resources/views/components/application-frame.blade.php` | Atlas branding, Atlas registries, Atlas component names and Atlas CSS selectors | Separate generic frame behavior from Atlas configuration | Atlas renders through `` and the full suite passes | | `app/Atlas/Experience/Workspaces/AtlasWorkspace.php` | ORBIT-CORE CANDIDATE | Immutable workspace definition | `packages/application-runtime/src/Workspaces/OrbitWorkspace.php` | Atlas namespace and potentially Atlas-specific field semantics | Generalize namespace, constructor validation and field naming | Atlas workspace records use `OrbitWorkspace` | | `app/Atlas/Experience/Workspaces/AtlasWorkspaceRegistry.php` | MIXED | Workspace lookup plus Atlas workspace declarations | Generic registry contract and resolver in Orbit-Core; declarations remain in Atlas | Atlas routes, titles, descriptions and destinations | Extract registry mechanism while preserving Atlas records locally | Atlas registry implements an Orbit-Core contract | | `app/Atlas/Experience/Navigation/AtlasExperienceNavigationItem.php` | ORBIT-CORE CANDIDATE | Immutable navigation destination definition | `packages/application-runtime/src/Navigation/OrbitNavigationItem.php` | Atlas namespace and destination assumptions | Generalize navigation item semantics | Atlas navigation declarations use the Orbit type | | `app/Atlas/Experience/Navigation/AtlasExperienceNavigationRegistry.php` | MIXED | Navigation declaration and resolution | Generic navigation registry contract in Orbit-Core; Atlas declarations remain local | Atlas routes, labels, product order and icons | Extract generic registry behavior | Atlas supplies navigation records through the package contract | | `app/Atlas/Experience/Navigation/AtlasNavigationBuilder.php` | MIXED | Builds navigation payloads for rendering | `packages/application-runtime/src/Navigation/OrbitNavigationBuilder.php` | Atlas DTOs, routes and naming conventions | Generalize builder inputs and output contract | Atlas consumes the package builder | | `app/Atlas/Experience/DTO/AtlasNavigationItem.php` | ORBIT-CORE CANDIDATE | Render-ready navigation DTO | `packages/application-runtime/src/Navigation/OrbitNavigationView.php` | Atlas namespace and field names | Consolidate or generalize with the package navigation model | No duplicate Atlas-only generic DTO remains | | Atlas primary navigation rendering inside the Application Frame | MIXED | Renders canonical application navigation | `packages/application-runtime/resources/views/components/navigation/primary.blade.php` | Atlas labels, routes, icons and selectors | Extract renderer and inject destinations | No Atlas-local generic application navigation renderer remains | | Atlas workspace header component | MIXED | Displays workspace identity and workspace-level actions | `packages/application-runtime/resources/views/components/workspace/header.blade.php` | Atlas selectors and Atlas terminology | Extract generic structure and preserve Atlas content through slots | Atlas uses `` | | Atlas toolbar components | ORBIT-CORE CANDIDATE | Reusable toolbar groups, separators and action regions | `packages/application-runtime/resources/views/components/navigation/` | Atlas namespace and CSS selectors | Generalize names and styling contracts | Atlas imports Orbit toolbar components | | Atlas panel header and panel shell | ORBIT-CORE CANDIDATE | Generic panel composition | Potential future `orbit/design-system` package or runtime-internal primitives | Atlas namespace and visual tokens | Decide whether RFC-0001 requires them or defers them to design-system RFC | Runtime no longer depends on Atlas-only generic panel primitives | | Atlas feedback status component | ORBIT-CORE CANDIDATE | Generic status presentation | Potential `orbit/design-system` package | Atlas tokens and selectors | Defer unless required by Application Frame v1 | Runtime package has no hidden Atlas component dependency | | Atlas document authority implementation | MIXED | Builds canonical document and workspace identity | `packages/application-runtime/src/Documents/` | Atlas product name and workspace labels | Extract title policy and inject application identity | Atlas uses Orbit document-title resolution | | `resources/css/atlas/application-frame.css` | MIXED | Application frame layout and shell behavior | `packages/application-runtime/resources/css/application-frame.css` | Atlas selectors, tokens and visual branding | Separate structural rules from Atlas presentation | Package provides the generic frame CSS | | `resources/css/atlas/workspace.css` | MIXED | Workspace containment and scrolling contracts | `packages/application-runtime/resources/css/workspace.css` | Atlas selectors and geospatial layout rules | Separate structural runtime CSS from Atlas product CSS | Generic shell CSS loads from the package | | `resources/css/atlas/navigation.css` | MIXED | Primary navigation layout and interaction states | `packages/application-runtime/resources/css/navigation.css` | Atlas branding and tokens | Split structural navigation behavior from Atlas theme | Atlas imports package navigation CSS and supplies theme tokens | | `resources/css/atlas/tokens.css` | MIXED / FUTURE PACKAGE | Design tokens used by the runtime | Candidate for `orbit/design-system` | Atlas naming and product palette | Extract only the minimum runtime token contract or defer to a dedicated RFC | Runtime package has a declared token dependency | | `resources/css/app.css` | COMPATIBILITY | Loads current Atlas shell and product styles | Atlas consumer integration | Atlas Vite pipeline | Replace generic local imports with package CSS imports | Package assets are consumed through the supported build path | | `scripts/atlas/audit_single_navigation_authority.py` | EVIDENCE / ORBIT-CORE CANDIDATE | Audits single application navigation authority | `packages/application-runtime/scripts/audit_navigation_authority.py` | Atlas paths, selectors and component names | Parameterize product root, namespaces and surfaces | Audit runs against Atlas and a second consumer | | `tests/Feature/Atlas/Shell/AtlasApplicationFrameTest.php` | EVIDENCE | Certifies Atlas Application Frame behavior | Split between Orbit package tests and Atlas consumer tests | Atlas views and labels | Extract generic frame assertions | Package and Atlas both certify their responsibilities | | `tests/Feature/Atlas/Shell/AtlasCanonicalNavigationAuthorityTest.php` | EVIDENCE | Certifies canonical navigation ownership | Orbit package certification plus Atlas integration test | Atlas page inventory | Extract reusable invariant assertions | Package and consumer navigation tests pass | | `tests/Feature/Atlas/Shell/AtlasSingleNavigationAuthorityTest.php` | EVIDENCE | Verifies one application navigation per Atlas surface | Atlas consumer certification | Atlas routes | Preserve as consumer evidence and parameterize reusable logic where useful | Atlas remains green after extraction | | `tests/Feature/Atlas/Shell/AtlasCanonicalWorkspaceRegistrationTest.php` | EVIDENCE | Certifies registry-driven frame composition | Orbit package tests plus Atlas consumer tests | Atlas registrations | Separate package behavior from consumer configuration | Both package and consumer tests pass | | `tests/Feature/Atlas/Shell/AtlasDesktopDocumentContractTest.php` | EVIDENCE | Certifies desktop document composition | Orbit certification suite plus Atlas integration test | Atlas routes and selectors | Split generic assertions from Atlas assertions | Orbit package and Atlas certify the contract | | `tests/Feature/Atlas/Shell/AtlasDocumentAuthorityTest.php` | EVIDENCE | Certifies canonical document authority | Orbit package tests plus Atlas consumer tests | Atlas labels and routes | Extract generic document policy tests | Atlas uses Orbit document authority | | `tests/Feature/Atlas/Shell/AtlasScrollingContractTest.php` | EVIDENCE | Certifies scrolling and containment | Orbit runtime certification suite | Atlas selectors | Replace Atlas-specific selectors with Orbit runtime selectors | Package tests enforce the generic contract | | `tests/Feature/Atlas/Experience/AtlasNavigationIntegrationTest.php` | EVIDENCE | Certifies navigation rendering across Atlas routes | Atlas consumer certification | Atlas routes and Publishing workflow | Preserve as reference-consumer test | Atlas remains green after package extraction | | `tests/Unit/Atlas/Experience/Workspaces/AtlasWorkspaceRegistryTest.php` | EVIDENCE | Certifies Atlas workspace declarations | Atlas | Atlas data | Retain product-specific assertions | Atlas registry implements Orbit contract | | `tests/Unit/Atlas/Experience/Workspaces/AtlasWorkspaceTest.php` | EVIDENCE | Certifies immutable workspace behavior | Candidate package unit test | Atlas namespace | Move generic behavior tests into the package and preserve product tests where needed | Orbit workspace type has package-level coverage | | `tests/Unit/Atlas/Experience/Navigation/AtlasExperienceNavigationRegistryTest.php` | EVIDENCE | Certifies Atlas navigation declarations and registry behavior | Split between package registry tests and Atlas declaration tests | Atlas navigation data | Extract generic registry behavior assertions | Both test layers pass | | `tests/Unit/Atlas/Experience/AtlasNavigationBuilderTest.php` | EVIDENCE | Certifies navigation payload construction | Orbit package unit tests | Atlas DTOs and routes | Generalize and migrate builder tests | Orbit navigation builder is package-owned | | Product composition certification tests | EVIDENCE | Prove Catalogue, Publishing, Observatory, Executive and Workspace compose canonically | Atlas | Atlas product routes and content | Retain in Atlas | Full Atlas consumer suite remains green | ## Components That Remain Inside Atlas The following are product-specific and must not be extracted into the generic application-runtime package: - map runtime; - map viewport; - map controls; - layer tree; - basemap selection; - geospatial search and identify; - dataset catalogue; - dataset publishing workflow; - spatial validation; - geospatial observatory; - spatial health sources; - spatial infrastructure views; - Atlas executive data; - Atlas missions; - dataset feeds; - alerts and operational evidence; - Atlas routes; - Atlas workspace declarations; - Atlas navigation records; - Atlas labels, icons and descriptions; - geospatial services and queries; - Atlas-specific JavaScript behavior. ## Package Boundary Orbit-Core owns: ```text generic type generic contract generic registry mechanism generic renderer generic composition generic lifecycle generic layout rule generic navigation authority generic document policy generic certification generic release ``` Atlas owns: ```text product configuration product routes product terminology product content product workflows product data product services product JavaScript product styling product adoption tests ``` ## Proposed Package Structure ```text orbit-core/ └── packages/ └── application-runtime/ ├── composer.json ├── README.md ├── CHANGELOG.md ├── LICENSE ├── src/ │ ├── OrbitApplicationRuntimeServiceProvider.php │ ├── Applications/ │ │ ├── OrbitApplication.php │ │ └── OrbitApplicationRegistry.php │ ├── Contracts/ │ │ ├── ApplicationRegistry.php │ │ ├── NavigationRegistry.php │ │ └── WorkspaceRegistry.php │ ├── Documents/ │ │ └── OrbitDocumentTitle.php │ ├── Navigation/ │ │ ├── OrbitNavigationBuilder.php │ │ ├── OrbitNavigationItem.php │ │ └── OrbitNavigationView.php │ ├── Workspaces/ │ │ ├── OrbitWorkspace.php │ │ └── OrbitWorkspaceResolver.php │ └── View/ │ └── Components/ ├── resources/ │ ├── views/ │ │ └── components/ │ │ ├── application-frame.blade.php │ │ ├── navigation/ │ │ │ └── primary.blade.php │ │ └── workspace/ │ │ └── header.blade.php │ └── css/ │ ├── runtime.css │ ├── application-frame.css │ ├── navigation.css │ └── workspace.css ├── scripts/ │ └── audit_navigation_authority.py └── tests/ ├── Unit/ ├── Feature/ └── Certification/ ``` This is a proposed structure. RFC-0001B will validate it against the actual extracted code before freezing public package namespaces. ## Consumer Integration Model Atlas should eventually install the package through Composer: ```json { "require": { "orbit/application-runtime": "^1.0" } } ``` During development, the package may be consumed through the Orbit-Core Git server: ```json { "repositories": [ { "type": "vcs", "url": "git@orbit-core.internal:orbit/application-runtime.git" } ] } ``` The final production model should use a private Composer repository operated by Orbit-Core. Example: ```text packages.orbit-core.internal ``` Products must pin resolved dependency versions in `composer.lock`. ## Intended Blade Consumption Atlas should ultimately compose through the Orbit package: ```blade ``` Aloqu should be able to use the same host: ```blade ``` WireShield should be able to use the same host: ```blade ``` The outer runtime remains stable. Only the product configuration and product surface change. ## Semantic Versioning The package will use semantic versioning. ### Patch Release ```text 1.0.1 ``` Used for backward-compatible bug fixes. ### Minor Release ```text 1.1.0 ``` Used for backward-compatible new capabilities. ### Major Release ```text 2.0.0 ``` Used for breaking public contract changes. Every package release must record: - RFC number; - package name; - package version; - Git commit; - Git tag; - compatibility range; - reference consumer; - reference consumer commit; - package test result; - consumer certification result. ## RFC Lifecycle Every implementation-bearing Orbit RFC follows this lifecycle: ```text PROPOSED ↓ IMPLEMENTATION AUDIT ↓ IMPLEMENTED ↓ REFERENCE-INTEGRATED ↓ CERTIFIED ↓ PUBLISHED ↓ ADOPTED ``` ### PROPOSED The problem, contract, alternatives and intended implementation are documented. ### IMPLEMENTATION AUDIT A proven product implementation is inventoried and classified for extraction. ### IMPLEMENTED The reusable package exists in Orbit-Core and has its own tests. ### REFERENCE-INTEGRATED A real product installs the package and replaces its local reusable implementation. ### CERTIFIED Both package tests and consumer tests pass. ### PUBLISHED The package is versioned, tagged and available from the Orbit-Core package service. ### ADOPTED A second product installs and uses the same package successfully. ## Migration Strategy ### Phase 1 — Inventory and Classification 1. Identify every candidate file. 2. Record its current responsibility. 3. classify it as ORBIT-CORE, ATLAS, MIXED, COMPATIBILITY or EVIDENCE. 4. Record its Atlas-specific dependencies. 5. Identify existing tests and audits. 6. Establish removal conditions. ### Phase 2 — Orbit-Core Repository Foundation 1. Create the Orbit-Core source repository. 2. Create the application-runtime package. 3. Add Composer metadata. 4. Add package namespaces. 5. Add package tests. 6. Add release metadata. 7. Store the normative RFC alongside the implementation. ### Phase 3 — Copy, Generalize and Certify 1. Copy the proven implementation without deleting Atlas code. 2. Remove Atlas-specific names and assumptions. 3. Define stable public contracts. 4. Build package-level unit tests. 5. Build package-level feature tests. 6. Build structural certification. 7. Publish development version `0.1.0`. ### Phase 4 — Atlas Reference Consumer Migration Migrate in this order: 1. immutable workspace type; 2. immutable navigation type; 3. generic registry contracts; 4. registry resolvers and builders; 5. document authority; 6. Application Frame; 7. primary navigation renderer; 8. workspace header; 9. structural runtime CSS; 10. reusable audits. Each migration step must preserve green tests. ### Phase 5 — Compatibility and Duplicate Removal 1. Introduce temporary adapters only where necessary. 2. Mark every adapter with a removal condition. 3. Remove duplicate local generic implementations after package adoption. 4. Confirm Atlas retains only product-specific implementation. 5. Confirm no competing shell or navigation authority remains. ### Phase 6 — Stable Release 1. Run the complete Orbit package suite. 2. Run the complete Atlas suite. 3. Run structural audits. 4. publish version `1.0.0`. 5. Tag the release. 6. Lock Atlas to the stable compatible range. 7. Record the package and consumer commits. ### Phase 7 — Second Product Adoption 1. Select Aloqu or WireShield. 2. Install `orbit/application-runtime`. 3. Register product identity and workspaces. 4. Render the canonical Application Frame. 5. Inject the product-specific surface. 6. Run consumer certification. 7. Record adoption evidence. ## Compatibility Policy The first stable release must define which versions it supports. Initial intended compatibility: ```text PHP: ^8.2 Laravel: ^12.0 Composer: ^2.5 ``` The final compatibility matrix must be verified in RFC-0001B package tests rather than assumed from this audit. ## Security and Trust Requirements The package must support ZeroTrust engineering principles: 1. Package source must come from the approved Orbit-Core repository. 2. Releases must be immutable once published. 3. Tags must correspond to reviewed commits. 4. Consumers must use lock files. 5. Package installation must not execute undocumented privileged operations. 6. Public contracts must reject invalid runtime configuration. 7. Navigation destinations must not bypass product authorization. 8. Rendering authority must not imply access authority. 9. Product authorization remains the responsibility of the consuming application. 10. Package updates must be reviewable and reversible. ## Testing Model RFC-0001 requires three test layers. ### Package Tests Owned by Orbit-Core. They verify: - immutable value objects; - registry contracts; - destination resolution; - active navigation resolution; - document title policy; - component rendering; - layout contract markers; - compatibility behavior. ### Consumer Tests Owned by Atlas. They verify: - Atlas registration data; - Atlas routes; - Atlas branding; - Atlas workflow navigation; - Atlas product content; - Atlas use of the package; - absence of duplicate local authority. ### Certification Tests Shared in principle and parameterized where practical. They verify: - exactly one application navigation; - no page-level application navigation; - correct frame composition; - deterministic document identity; - shell and scrolling invariants; - product-surface insertion; - absence of retired compatibility behavior. ## Required Evidence RFC-0001A must preserve or generate evidence for: - source commit; - source branch; - candidate PHP files; - candidate Blade files; - candidate CSS files; - candidate tests; - candidate audit scripts; - Application Frame usage; - workspace registry usage; - navigation authority usage; - document authority usage; - containment and scrolling usage; - Atlas coupling; - framework coupling; - focused certification output; - structural audit output. This evidence belongs under: ```text storage/stage-baselines/orbit-rfc-0001a-runtime-extraction/ ``` Unless repository policy explicitly changes, baseline evidence remains untracked. ## Non-Goals RFC-0001 does not attempt to extract: - Atlas geospatial services; - Atlas map rendering; - Atlas dataset models; - Atlas publishing business logic; - Atlas observatory queries; - Atlas infrastructure adapters; - Atlas executive metrics; - identity, billing or tenancy; - a universal frontend framework for every language; - Java, .NET, C++ or JavaScript package implementations. RFC-0001 proves the Orbit-Core package and consumption model first through Laravel and Composer. Equivalent packages for other technology families can follow once the governance, versioning, certification and release model has been proven. ## Risks ### Premature Generalization Moving Atlas code without understanding product dependencies may produce an Atlas package with a generic name. **Control:** classify and split mixed files before extraction. ### Copy-Based Reuse Products may copy package files rather than install the dependency. **Control:** require package-manager consumption and consumer lock files. ### Hidden Product Dependencies A generic component may still depend on Atlas routes, components, CSS or labels. **Control:** package tests must run independently of Atlas. ### Competing Authorities Compatibility adapters may accidentally remain as permanent navigation or frame authorities. **Control:** enforce single-authority certification and explicit adapter removal conditions. ### Unstable Public API Publishing `1.0.0` too early may freeze poor abstractions. **Control:** use development releases before the stable release. ### Design-System Entanglement The runtime may depend on broad Atlas visual components that belong in a separate design-system package. **Control:** extract only minimum structural primitives for RFC-0001 and document deferred candidates. ## Decisions Required During RFC-0001B RFC-0001B must resolve: 1. the permanent Orbit-Core server path; 2. the Git repository name; 3. whether Orbit-Core uses a monorepository or one repository per package; 4. the permanent PHP namespace; 5. the Blade component namespace; 6. the private Composer repository endpoint; 7. the minimum CSS token contract; 8. package asset publication versus direct package imports; 9. Laravel package auto-discovery; 10. exact supported PHP and Laravel versions; 11. release tagging convention; 12. package signing or provenance controls; 13. second reference consumer selection. ## RFC Completion Criteria RFC-0001 is complete only when: - Orbit-Core contains the package implementation; - the package has its own independent test suite; - the package has semantic version metadata; - the package can be installed from the Orbit-Core server; - Atlas installs the package through Composer; - Atlas no longer owns duplicate generic implementation; - Atlas retains only product-specific behavior and configuration; - the complete Atlas test suite passes; - structural runtime audits pass; - the package is tagged `1.0.0`; - release metadata identifies the reference consumer; - a second ZeroTrust product installs and renders the same runtime; - second-consumer certification passes. ## RFC-0001A Completion Criteria RFC-0001A is complete when: - all candidate implementation files have been inventoried; - ownership classifications have been recorded; - mixed responsibilities have been identified; - proposed package destinations have been recorded; - Atlas-specific coupling has been measured; - existing certification has been rerun; - extraction order is defined; - removal conditions are explicit; - the extraction register is committed; - no production implementation has yet been moved. ## Current Conclusion ZeroTrust Atlas has proven a reusable application runtime consisting of: - a canonical Application Frame; - registry-driven application and workspace identity; - a single navigation authority; - canonical document authority; - deterministic shell containment; - deterministic scrolling ownership; - explicit product-surface composition; - immutable workspace and navigation definitions; - automated architectural certification; - structural navigation auditing. The Atlas map is not the reusable runtime. The map is Atlas's product surface. The reusable implementation is the host, registry, authority and certification system surrounding that surface. The implementation is mature enough to begin extraction into Orbit-Core, provided the extraction preserves the distinction between generic runtime behavior and Atlas-specific geospatial behavior. ## Next Milestone ```text ORBIT RFC-0001B Orbit Application Runtime Package Foundation ``` RFC-0001B will create the actual Orbit-Core package: ```text orbit/application-runtime ``` It will establish: - Composer packaging; - namespaces; - contracts; - immutable runtime definitions; - Laravel service-provider integration; - package views; - package CSS; - package tests; - release metadata; - first development release. Atlas will then become the first external consumer during RFC-0001C. ## Decisions The following decisions are frozen by this RFC. 1. Orbit-Core owns reusable application runtime behavior. 2. Atlas owns only geospatial product behavior. 3. Generic runtime components SHALL be extracted into Orbit packages. 4. Atlas SHALL become the first reference consumer. 5. Future reusable abstractions SHALL be proposed in new RFCs rather than modifying RFC-0001. 6. RFC-0001 is closed after Atlas adoption. ## Implementation Roadmap RFC-0001B Orbit Application Framework Foundation Objective Create the first Orbit package: orbit/application-framework Deliverables - Composer package - Package namespace - Service provider - Contracts - Runtime definitions - Package tests - Version metadata --- RFC-0001C Atlas Runtime Adoption Objective Replace Atlas-owned runtime implementations with Orbit package consumption. --- RFC-0001D Reference Consumer Certification Objective Certify Atlas as the first Orbit consumer. --- RFC-0001E Second Consumer Adoption Objective Adopt the Orbit Application Framework within Aloqu to validate cross-product reuse. ## RFC Closure RFC-0001 is complete when: ✓ Orbit Application Framework exists. ✓ Atlas consumes the package. ✓ Atlas certification passes. ✓ The package is versioned. ✓ The package is reusable by another ZeroTrust product. After these conditions are met, RFC-0001 enters permanent maintenance mode. Any future enhancements require new RFCs.