@ccslabs/xtend 0.1.0-rc.1 → 0.1.2

package/docs/rmt-vnext-primitive-authoring-tooling.md

@@ -0,0 +1,247 @@
+# RMT vNext Primitive Authoring Tooling
+
+- Contract: `xtend.rmt.vnext.primitive-authoring-tooling.v1`
+- Workpackage: `RMT-VNEXT-PRIM-07`
+- Status: `completed`
+- Quelle: Media-Manager-Downstream-Transfer, `2026-05-19`
+
+## Ziel
+
+`RMT-VNEXT-PRIM-07` macht die neue Primitive-Syntax in der Developer
+Experience sichtbar. App-Autoren sollen State, Selectors, Actions, Events,
+Surfaces, Portals, Overlays und Resources nicht in Legacy-JSON suchen muessen:
+Completions, Hover, Document Symbols und Snippets fuehren direkt durch RMT
+vNext.
+
+## Tooling Surface
+
+Die erste PRIM-07-Scheibe erweitert `tools/rmt-language/vnext-tooling.js`.
+Das Modul indexiert nun auch Primitive-Domains aus PRIM-04:
+
+- `states`
+- `selectors`
+- `actions`
+- `effects`
+- `portals`
+- `overlays`
+- `resources`
+
+Bestehende Domains wie `surfaces`, `events` und `dataSources` bleiben erhalten
+und werden fuer Primitive-Records angereichert.
+
+## Completions
+
+Neue Completion-Kontexte:
+
+| Context | Zweck |
+| --- | --- |
+| `vnext-primitive-keywords` | top-level Primitive-Keywords wie `state`, `selector`, `action`, `surface`, `resource` |
+| `vnext-primitive-state-clauses` | `type`, `preserve`, `initial` |
+| `vnext-primitive-selector-clauses` | `from state`, `where`, `find`, `sort by`, `output` |
+| `vnext-primitive-action-clauses` | `input`, `reduce`, `effect fetch datasource`, `on success`, `on error`, `emit` |
+| `vnext-primitive-surface-clauses` | `source selector`, `repeat from selector`, `key`, `portal`, `bounds`, `lane visible`, Event- und Lifecycle-Klauseln |
+| `vnext-primitive-resource-kinds` | `object-url`, `stream`, `observer`, `timer`, `lazy-import` |
+| `vnext-primitive-overlay-kinds` | `tooltip`, `toast`, `popover`, `lightbox`, `menu`, `dialog` |
+
+Wenn ein Pointer in einer Primitive-Domain liegt, waehlt das Tooling den
+passenden Kontext automatisch.
+
+### Cursor-nahe Completion
+
+Die zweite PRIM-07-Scheibe macht Completion ohne expliziten
+`xtend.context` nutzbar. `getRmtVNextToolingCompletions(...)` akzeptiert nun
+eine LSP-Position, loest daraus wenn moeglich den Source-Map-Pointer auf und
+wertet die aktuelle Zeile sowie das Teilwort vor dem Cursor aus.
+
+Abgedeckte Authoring-Faelle:
+
+- `state ... {` liefert direkt State-Klauseln wie `initial`.
+- `resource ... kind ` liefert Resource-Kinds wie `lazy-import`.
+- Teilwoerter in Action-Bloecken, z. B. `red`, priorisieren Action-Klauseln
+  wie `reduce`.
+
+Der Language Server reicht `textDocument/completion.position` an das vNext-
+Tooling weiter. Damit bekommen Editoren Primitive-Completions auch dann, wenn
+sie keine XTend-spezifischen Zusatzparameter setzen.
+
+## Hover
+
+Hover nutzt die PRIM-04-Core-Records und Source Maps. Beispiele:
+
+- `State: media.records`
+- `Action: media.select`
+- `Resource: lightbox.import`
+
+Die Hover-Ausgabe enthaelt weiterhin Core Pointer, damit Editor, Compiler und
+Runtime-Evidence dieselbe Primitive-ID nachvollziehen koennen.
+
+## Document Symbols
+
+Document Symbols enthalten nun Primitive-Namespaces:
+
+```text
+states
+selectors
+actions
+portals
+overlays
+resources
+surfaces
+events
+```
+
+Damit kann ein Editor eine granulare App Shell aus der Outline heraus
+navigieren, ohne Legacy-Records zu oeffnen.
+
+## Code Actions
+
+Die dritte PRIM-07-Scheibe liefert sichere Quick-Fixes fuer Primitive-
+Diagnosen aus `getRmtVNextToolingCodeActions(...)` und ueber
+`textDocument/codeAction` im Language Server.
+
+Unterstuetzte erste Reparaturen:
+
+- `rmt.vnext.primitive.owner-missing`: ergaenzt `owner surface.<id>` an einer
+  Resource-Deklaration, wenn eine Surface im Dokument vorhanden ist.
+- `rmt.vnext.primitive.unkeyed-repeat`: ergaenzt `key instance.id` nach einer
+  `repeat from selector`-Klausel.
+- `rmt.vnext.primitive.payload-contract-missing`: ergaenzt einen
+  Payload-Contract fuer Event-Bindings oder `emit`-Statements.
+
+Die naechste Scheibe erweitert diese Reparaturen um die haeufigsten
+Authoring-Luecken:
+
+- `rmt.vnext.primitive.initial-missing`: ergaenzt einen sicheren initial-Wert
+  oder einen kleinen `initial {}`-Block.
+- `rmt.vnext.primitive.resource-kind-missing`: ergaenzt `kind object-url` als
+  konservativen Resource-Default.
+- `rmt.vnext.primitive.unknown-reference` fuer Selector-Referenzen: erzeugt
+  einen source-erhaltenden Selector-Stub aus dem ersten vorhandenen State.
+- `rmt.vnext.primitive.unknown-reference` fuer Portal-Referenzen: erzeugt einen
+  Portal-Stub mit stabilem `root` und `layer surface`.
+
+Die Action-Authoring-Scheibe ergaenzt ausserdem:
+
+- `rmt.vnext.primitive.action-reducer-missing`: ergaenzt ein
+  `reduce state.<id> = input.<name>`-Ziel vor dem Action-Ende.
+- `rmt.vnext.primitive.effect-source-missing`: ergaenzt
+  `datasource <id>` an einem `effect fetch`.
+- `rmt.vnext.primitive.kernel-boundary`: erzeugt bewusst keinen Textedit,
+  sondern ein Command-Action-Handoff, damit Kernel-/Fabric-Imports in einen
+  Host-Adapter ausgelagert werden.
+
+Die Actions sind absichtlich source-erhaltende Textedits. Sie reparieren die
+naheliegende Authoring-Luecke und lassen weitergehende semantische Probleme
+sichtbar, statt ganze Primitive-Bloecke synthetisch umzuschreiben.
+
+### Code-Action-Previews und Fix-All
+
+Die naechste PRIM-07-Scheibe macht die Quick-Fixes editorfreundlicher:
+
+- Jede Code Action traegt eine `xtend.rmt.vnext.primitive-code-action-preview.v1`
+  Preview mit betroffenen URIs, Edit-Anzahl, erstem veraenderten Source-Line-
+  Ausschnitt und Vorher-/Nachher-Zeilen.
+- Sichere Textedit-Actions werden zusaetzlich in
+  `source.fixAll.rmt.vnext.primitives` zusammengefasst.
+- Das Fix-All bleibt auf Actions mit `safe: true` und `edit` begrenzt.
+  Manuelle Command-Handoffs wie `kernel-boundary` werden nicht automatisch
+  angewendet.
+- Der Language Server gibt die Preview im `CodeAction.data.preview`-Feld
+  weiter, damit Editoren eine Reparatur anzeigen koennen, bevor sie den
+  WorkspaceEdit anwenden.
+
+### Command-Handoff
+
+Manuelle Boundary-Faelle bekommen jetzt ebenfalls eine stabile Editor-
+Erfahrung:
+
+- Der Language Server meldet `executeCommandProvider.commands` mit
+  `xtend.rmt.vnext.extractKernelImport`.
+- `workspace/executeCommand` erzeugt fuer diesen Command ein
+  `xtend.rmt.vnext.primitive-command-handoff.v1` Ergebnis.
+- Das Ergebnis bleibt `safe: false`, `edit: null` und `status:
+  "manual_handoff"`, weil Kernel-/Fabric-Imports nicht automatisch in RMT
+  vNext-Source geschrieben werden duerfen.
+- Der Handoff benennt die Boundary
+  `no-kernel-fabric-imports-in-vnext-source` und fuehrt den Zielort
+  `xtend-rmt-host-adapter`, damit Editoren einen klaren manuellen Apply-Pfad
+  anzeigen koennen.
+
+### VS Code Bridge Apply Experience
+
+Die VS-Code-Bridge bietet nun eine erste sichtbare Authoring-Erfahrung fuer
+die drei Apply-Pfade:
+
+- `XTendRMT: Show vNext Primitive Apply Experience` rendert einen
+  `xtend.rmt.editor.vscode-primitive-authoring-experience.v1` Report im
+  Output Channel.
+- `XTendRMT: Show vNext Primitive Code Action Preview` zeigt den Preview-
+  Ausschnitt einer einzelnen Code Action.
+- `XTendRMT: Show vNext Primitive Command Handoff` zeigt manuelle Boundary-
+  Handoffs ohne WorkspaceEdit.
+
+Die Bridge bleibt bewusst duenn: sie klassifiziert bereits vom Language Server
+gelieferte Actions in `workspace-edit`, `fix-all` und `manual-command` und
+macht diese Pfade sichtbar. Der LSP bleibt die Source of Truth fuer Diagnose,
+Preview und Command-Handoff.
+
+### Aktive VS-Code-Dokument-Integration
+
+Die abschliessende PRIM-07-Scheibe verbindet die Bridge mit dem aktiven
+`.rmt`-Dokument:
+
+- `createActiveDocumentPrimitiveAuthoringExperience(...)` liest das aktive
+  Dokument, startet den lokalen RMT Language Server in-process und ruft
+  `textDocument/codeAction` gegen echte LSP-Diagnosen ab.
+- `XTendRMT: Show vNext Primitive Apply Experience` kann ohne uebergebenen
+  Report direkt aus dem aktiven Dokument eine QuickPick-Auswahl fuer Preview,
+  Fix-All und manuelle Handoffs aufbauen.
+- `applyPrimitiveAuthoringWorkspaceEdit(...)` wendet nur sichere
+  WorkspaceEdits an. `kernel-boundary`-Actions bleiben blockiert, weil sie
+  `edit: null` tragen und in einen Host-Adapter ueberfuehrt werden muessen.
+- `XTendRMT: Apply Safe vNext Primitive Fix-All` wendet ausschliesslich
+  `source.fixAll.rmt.vnext.primitives` an. Wenn kein sicherer Fix-All
+  verfuegbar ist, rendert die Bridge den aktuellen Apply-Report statt blind
+  einzelne Edits auszufuehren.
+
+Damit ist PRIM-07 nicht mehr nur ein LSP-/Dokumentationspaket: Die
+Editor-Bruecke kann vNext-Primitive-Reparaturen aus echtem Source-Kontext
+auswaehlen, previewen und sicher anwenden, waehrend Boundary-Handoffs sichtbar
+und manuell bleiben.
+
+## Snippet
+
+Neues Snippet:
+
+```text
+RMT vNext Primitive Shell
+```
+
+Prefix:
+
+```text
+rmt-vnext-primitive-shell
+```
+
+Das Snippet erzeugt eine kleine App Shell mit State, Selector, Action, Portal,
+Surface, sichtbarer Lane und Event-Payload-Contract.
+
+## Lokale Gates
+
+```bash
+node --check tools/rmt-language/vnext-tooling.js
+node --check tests/rmt-language/rmt_vnext_tooling_suite.js
+node -e "const suite=require('./tests/rmt-language/rmt_vnext_tooling_suite'); const result=suite.runRmtVNextToolingSuite({rootDir:process.cwd()}); process.exit(result.ok ? 0 : 1);"
+```
+
+Der globale Runner fuehrt `rmt-vnext-tooling` und `rmt-editor-packaging` als
+Release-Gates aus. Die VS-Code-Bridge wird ueber
+`node scripts/run_xtend_tests.js rmt-editor-packaging --json` gegen aktive
+Dokument-CodeActions, Safe-Fix-All und blockierte Kernel-Boundary-Handoffs
+geprueft.
+
+## Naechster Handoff
+
+`RMT-VNEXT-PRIM-07` ist abgeschlossen. Weitere Editor-Arbeit kann auf dieser
+Bridge aufsetzen, etwa echte LanguageClient-Verpackung oder UI-spezifische
+Preview-Panels; der vNext-Primitive-Authoring-Pfad selbst ist release-gated.

package/docs/rmt-vnext-primitive-grammar-design.md

@@ -0,0 +1,289 @@
+# RMT vNext Primitive Grammar Design
+
+- Contract: `xtend.rmt.vnext-primitive-grammar-design.v1`
+- Workpackage: `RMT-VNEXT-PRIM-01`
+- Status: `completed`
+- Parent backlog: [RMT vNext Primitive Compiler Backlog](./rmt-vnext-primitives-compiler-backlog.md)
+- Design fixture: `tests/rmt-language/fixtures/vnext-primitives-grammar-design.rmt`
+
+## Ziel
+
+Dieser Slice definiert die vNext-Syntax, mit der App-Platform-Primitives direkt
+in RMT authoriert werden sollen. Er ist bewusst ein Grammar-Design-Contract.
+Parser-/AST-Implementierung ist in `RMT-VNEXT-PRIM-02` abgeschlossen; die erste
+Semantic-Graph-Schicht ist in `RMT-VNEXT-PRIM-03` gestartet. Compiler-Lowering
+folgt in `RMT-VNEXT-PRIM-04`.
+
+Die Syntax muss App-Autoren aus Legacy-/JSON-Authoring herausfuehren. Ein
+normaler App-Shell-Entwickler soll State, Selectors, Actions, Events,
+DataSources, Surfaces, Overlays, Portals und Resources in einer lesbaren RMT
+vNext-Datei deklarieren koennen.
+
+## Design-Prinzipien
+
+- **vNext first:** Die menschenfreundliche DSL ist die primaere Authoring-
+  Oberflaeche. JSON bleibt Compiler-Output oder Migrationsinput.
+- **Kernel-neutral:** Syntax kann XTend-Komponenten referenzieren, aber der
+  RMT-Kernel importiert keine XTend-, Fabric- oder Browser-Module.
+- **App-Graph vor Runtime:** Referenzen, Ownership, Payload Contracts und
+  Trust Boundaries muessen aus dem Source Graph pruefbar sein.
+- **Source-map-faehig:** Jede Primitive-Deklaration braucht einen stabilen
+  Source Range und eine Primitive ID.
+- **Composable:** App Shell, UI-Templates, State, Events und Resources duerfen
+  getrennt deklarierbar sein, muessen aber zu einem App Graph verbunden werden.
+- **Legacy im Hintergrund:** Klassische Core-/Scaffold-Artefakte duerfen
+  weiterhin Targets sein, aber Entwickler sollen sie nicht bearbeiten muessen.
+
+## Top-Level-Grammatik
+
+Eine vNext-Datei kann weiterhin `import`, `template`, `surface` und `remote`
+nutzen. Neu kommen primitive Deklarationen hinzu. Sie sind innerhalb eines
+`template`-Blocks bevorzugt, duerfen fuer wiederverwendbare Bibliotheken aber
+auch top-level authoriert werden.
+
+```rmt
+template media.manager {
+  state media.records type MediaRecord[] initial []
+
+  selector media.filtered from state media.records {
+    where record.kind == state.media.filters.kind || state.media.filters.kind == "all"
+    sort by record.name asc
+  }
+
+  datasource media.index from endpoint "/api/media?pageSize=200" {
+    method GET
+    contract MediaIndex
+    result records
+  }
+
+  action media.select {
+    input mediaId string
+    reduce state.media.selection.activeId = input.mediaId
+    emit media.selected with mediaId input.mediaId
+  }
+
+  portal surface.root root "#media-manager-root" layer surface
+  overlay feedback.toast kind toast portal surface.root
+  resource player.stream kind stream owner surface.player source state.media.selection.activeId
+
+  surface media.explorer kind window component x-surface-window {
+    source selector media.filtered
+    key record.id
+    portal surface.root
+
+    lane visible weight 80 {
+      hydrate explorer-list from selector media.filtered
+    }
+
+    on click "[data-media-id]" -> action media.select {
+      payload mediaId from target.dataset.mediaId
+    }
+  }
+}
+```
+
+## Primitive-Formen
+
+### State
+
+```rmt
+state media.filters type object preserve {
+  initial {
+    query ""
+    kind "all"
+    collection "all"
+  }
+}
+```
+
+Lowering-Ziel:
+
+- `core.state[]`
+- Source-map entry mit `primitiveType: "state"`
+- optionaler XState-Bridge-Hint fuer Host-Adapter
+
+### Selector
+
+```rmt
+selector media.filtered from state media.records {
+  where record.kind == state.media.filters.kind || state.media.filters.kind == "all"
+  where contains(record.name, state.media.filters.query)
+  sort by record.name asc
+  output MediaRecord[]
+}
+```
+
+Einschraenkung fuer PRIM-01: Funktionen wie `contains()` sind als deklarative
+Selector-Operatoren erlaubt, aber nicht als beliebige JS-Calls. PRIM-02 muss
+sie als eigene AST-Nodes modellieren.
+
+Lowering-Ziel:
+
+- `core.selectors[]`
+- Referenzen auf `core.state[]`
+- Diagnose fuer unbekannte State- oder Record-Pfade
+
+### DataSource
+
+```rmt
+datasource media.index from endpoint "/api/media?pageSize=200" {
+  method GET
+  contract MediaIndex
+  result records
+  fallback fixture media.fixture
+}
+```
+
+Lowering-Ziel:
+
+- `core.dataSources[]`
+- App-Platform-Report-Domain `dataSources`
+- optionaler SSR-/Fixture-Fallback
+
+### Action und Effect
+
+```rmt
+action media.reindex {
+  status state.actionStatus.reindex
+  effect fetch datasource media.reindex
+  on success -> reduce state.media.records = result.records
+  on success -> emit media.index.loaded with count result.records.length
+  on error -> overlay feedback.toast message error.message tone "danger"
+}
+```
+
+Lowering-Ziel:
+
+- `core.actions[]`
+- `core.effects[]` oder action-scoped `effects`
+- Event-/Feedback-Result-Routing
+- Resource ownership fuer async handles
+
+### Event Binding
+
+```rmt
+on click "[data-command='scan']" -> action media.reindex {
+  preventDefault true
+  payload source from target.dataset.command
+}
+
+on xplayer-play target player.surface -> action media.playback.started {
+  payload mediaId from detail.mediaId
+  payload surfaceId from surface.id
+}
+```
+
+Lowering-Ziel:
+
+- `core.events[]`
+- Payload Contract
+- DOM/custom event routing metadata
+- Source pointer fuer jedes Payload Mapping
+
+### Surface
+
+```rmt
+surface media.player kind window component x-surface-window {
+  repeat from selector player.instances
+  key instance.surfaceId
+  portal surface.root
+  bounds x 920 y 96 width 760 height 500
+  preserve on minimize
+  destroy releases resource player.stream
+
+  lane visible weight 90 {
+    hydrate player-view from selector media.activeRecord
+  }
+}
+```
+
+Lowering-Ziel:
+
+- `core.surfaces[]`
+- `core.lanes[]`
+- `core.operations[]`
+- Surface Graph Runtime records
+- keyed repeater diagnostics
+
+### Portal und Overlay
+
+```rmt
+portal overlay.root root "body" layer overlay z 1000 {
+  focus policy restore
+  pointer policy passthrough
+  scroll policy lock-when-modal
+}
+
+overlay media.lightbox kind lightbox portal overlay.root {
+  escape close topmost
+  focus trap
+  resource lightbox.import
+}
+```
+
+Lowering-Ziel:
+
+- `core.portals[]`
+- `core.overlays[]`
+- portal reference diagnostics
+- overlay stack policy
+
+### Resource
+
+```rmt
+resource lightbox.import kind lazy-import owner overlay.media.lightbox {
+  import "@ccslabs/xtend/components/xlightbox"
+}
+
+resource preview.objectUrl kind object-url owner surface.media.player {
+  source selector media.activeRecord
+  dispose on surface.destroy
+}
+```
+
+Lowering-Ziel:
+
+- `core.resources[]`
+- owner-scoped lifecycle records
+- teardown diagnostics fuer ownerless resources
+
+## AST-Node-Namen
+
+PRIM-02 soll mindestens diese Node-Typen erzeugen:
+
+| Syntax | AST Node |
+|--------|----------|
+| `state` | `RmtStateDeclaration` |
+| `selector` | `RmtSelectorDeclaration` |
+| `datasource` | `RmtDataSourceDeclaration` |
+| `action` | `RmtActionDeclaration` |
+| `effect` | `RmtEffectStatement` |
+| `on ... -> action ...` | `RmtEventBinding` mit Payload-Block |
+| `surface ... kind ... component ...` | `RmtSurfaceDeclaration` mit Primitive-Metadata |
+| `portal` | `RmtPortalDeclaration` |
+| `overlay` | `RmtOverlayDeclaration` |
+| `resource` | `RmtResourceDeclaration` |
+| `template` primitive block | `RmtTemplateDeclaration.body[]` |
+
+## Diagnostik-Mindestumfang
+
+Der Grammar-Slice definiert folgende Fehlerklassen fuer PRIM-02/03:
+
+| Code | Bedeutung |
+|------|-----------|
+| `rmt.vnext.primitive.unknown-reference` | Primitive referenziert unbekannten State, Selector, Action, Portal, Resource oder Surface. |
+| `rmt.vnext.primitive.owner-missing` | Resource oder Overlay besitzt keinen stabilen Owner. |
+| `rmt.vnext.primitive.unkeyed-repeat` | Surface oder Template wiederholt Records ohne `key`. |
+| `rmt.vnext.primitive.payload-contract-missing` | Event bindet eine Action ohne Payload Contract oder Mapping. |
+| `rmt.vnext.primitive.unsafe-html` | Template nutzt HTML ohne Trusted-DOM-Boundary. |
+| `rmt.vnext.primitive.kernel-boundary` | Primitive verlangt Kernel-Import aus XTend, Fabric oder Browser Runtime. |
+
+## Akzeptanz fuer PRIM-01
+
+- Dieses Dokument definiert eine zusammenhaengende vNext-Syntax fuer alle P0-
+  Primitive-Familien.
+- Die Fixture `tests/rmt-language/fixtures/vnext-primitives-grammar-design.rmt`
+  zeigt denselben Syntaxumfang in einer kompakten App-Shell.
+- Das Backlog markiert `RMT-VNEXT-PRIM-01` als `in_progress`.
+- PRIM-02 kann direkt mit Parser-/AST-Arbeit starten, ohne die Syntaxfrage neu
+  zu klaeren.

package/docs/rmt-vnext-primitive-lowering.md

@@ -0,0 +1,108 @@
+# RMT vNext Primitive Lowering
+
+- Contract: `xtend.rmt.vnext.primitive-lowering.v1`
+- Workpackage: `RMT-VNEXT-PRIM-04`
+- Status: `completed`
+- Quelle: Media-Manager-Downstream-Transfer, `2026-05-19`
+
+## Ziel
+
+`RMT-VNEXT-PRIM-04` senkt validierte vNext-Primitives aus dem PRIM-03 Semantic
+Graph in deterministische Core-, App-Platform- und Kernel-Records ab. App-
+Autoren bleiben dabei in RMT vNext; JSON bleibt Compiler-Output und nicht der
+Authoring-Pfad.
+
+Die Lowering-Stufe ist Teil des bestehenden vNext-Compilers:
+
+```js
+const {
+  compileRmtVNextSource
+} = require('./tools/rmt-language/vnext-compiler');
+
+const result = compileRmtVNextSource({ text, filePath });
+```
+
+Bei Primitive-Quellen baut der Compiler zuerst
+`buildRmtVNextPrimitiveSemanticGraph(...)`. Error-Diagnostics aus dem Graph
+stoppen das Lowering mit `status: "semantic_error"` und ohne Core-Document.
+
+## Core-Domains
+
+Der vNext-Core erhaelt zusaetzliche Primitive-Domains:
+
+- `states`
+- `selectors`
+- `actions`
+- `effects`
+- `portals`
+- `overlays`
+- `resources`
+
+Vorhandene Domains wie `surfaces`, `lanes`, `operations`, `events` und
+`dataSources` werden fuer Primitive angereichert, statt einen zweiten Runtime-
+Pfad zu erzeugen.
+
+## App-Platform Artifact
+
+Wenn Primitive vorhanden sind, enthaelt das Core-Document `appPlatform`:
+
+```json
+{
+  "schema": "xtend.rmt.vnext.app-platform-records.v1",
+  "sourceSyntax": "rmt-vnext",
+  "surfaces": [],
+  "events": [],
+  "resources": []
+}
+```
+
+Dieses Artefakt ist fuer Host-/Scaffold-Adapter gedacht. Host-spezifische
+Imports, etwa Lazy Component Imports, bleiben dort sichtbar und tragen
+`kernelVisible: false`.
+
+## Kernel Records
+
+Das Core-Document enthaelt bei Primitive-Quellen ausserdem `kernelRecords`:
+
+```json
+{
+  "schema": "xtend.rmt.vnext.kernel-records.v1",
+  "boundary": "no-rmt-kernel-import-of-host-runtime-types",
+  "schedules": [],
+  "fibers": [],
+  "lifecycleRecords": []
+}
+```
+
+Der Kernel-Record-Slice enthaelt Lanes, Fibers, Lifecycle-, State-, Selector-,
+Action-, DataSource- und Resource-Fakten ohne Host-Runtime-Imports. Dadurch ist
+PRIM-05 vorbereitet: Fabric kann Lane/Fiber-Evidence aus Compiler-Output
+ableiten, ohne dass der Kernel Fabric oder XTend importieren muss.
+
+## Evidence
+
+Die Compiler-Suite prueft:
+
+- positive Primitive-Fixture kompiliert zu State-, Selector-, DataSource-,
+  Action-, Effect-, Portal-, Overlay-, Resource-, Surface- und Event-Records;
+- App-Platform-Artefakt und Kernel-Records werden erzeugt;
+- keyed Surface-Repeater und Event-Payload-Contracts bleiben erhalten;
+- Host-Imports bleiben ausserhalb der Kernel-Sichtbarkeit;
+- negative PRIM-03-Fixture stoppt vor dem Lowering mit Semantic-Diagnostics;
+- Core JSON bleibt byte-stabil.
+
+Gezielte lokale Gates:
+
+```bash
+node --check tools/rmt-language/vnext-compiler.js
+node --check tests/rmt-language/rmt_vnext_compiler_suite.js
+node -e "const suite=require('./tests/rmt-language/rmt_vnext_compiler_suite'); const result=suite.runRmtVNextCompilerSuite({rootDir:process.cwd()}); process.exit(result.ok ? 0 : 1);"
+```
+
+## PRIM-06 Anschluss
+
+`RMT-VNEXT-PRIM-06` setzt auf `kernelRecords.schedules` und
+`kernelRecords.fibers` auf. Die erste Source-to-Sea-Scheibe erzeugt daraus
+Evidence, die vNext-Source-Maps, Kernel-Schedules, ableitbare Fabric-Fibers,
+UI-Marker und eine Browser-Smoke-Fixture unter derselben Primitive-ID
+korreliert.