@ccslabs/xtend 0.1.0-rc.1 → 0.1.2

package/tools/rmt-language/vnext-tooling.js

@@ -12,6 +12,7 @@ const RMT_VNEXT_TOOLING_SCHEMA = 'xtend.rmt.vnext-tooling-adapter.v1';
 const RMT_VNEXT_TOOLING_REPORT_SCHEMA = 'xtend.rmt.vnext-tooling-report.v1';
 const RMT_VNEXT_TOOLING_FORMATTER_SCHEMA = 'xtend.rmt.vnext-formatter.v1';
 const RMT_VNEXT_TOOLING_WORKPACKAGE = 'WP-E15-15';
+const RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE = 'RMT-VNEXT-PRIM-07';
 const RMT_VNEXT_TOOLING_MODULE_PATH = 'tools/rmt-language/vnext-tooling.js';
 const RMT_VNEXT_TOOLING_SUITE_PATH = 'tests/rmt-language/rmt_vnext_tooling_suite.js';
 const RMT_VNEXT_TOOLING_PACKAGE_SCRIPT = 'npm run test:rmt-vnext-tooling';
@@ -30,6 +31,14 @@ const RMT_DOCUMENT_SYMBOL_SCHEMA = 'xtend.rmt.document-symbol.v1';
 const RMT_DEFINITION_REPORT_SCHEMA = 'xtend.rmt.definition-report.v1';
 const RMT_DEFINITION_PROVIDER_SCHEMA = 'xtend.rmt.definition-provider.v1';
 const RMT_DEFINITION_TARGET_SCHEMA = 'xtend.rmt.definition-target.v1';
+const RMT_VNEXT_PRIMITIVE_CODE_ACTION_PROVIDER_SCHEMA = 'xtend.rmt.vnext.primitive-code-action-provider.v1';
+const RMT_VNEXT_PRIMITIVE_CODE_ACTION_REPORT_SCHEMA = 'xtend.rmt.vnext.primitive-code-action-report.v1';
+const RMT_VNEXT_PRIMITIVE_CODE_ACTION_PREVIEW_SCHEMA = 'xtend.rmt.vnext.primitive-code-action-preview.v1';
+const RMT_VNEXT_PRIMITIVE_FIX_ALL_KIND = 'source.fixAll.rmt.vnext.primitives';
+const RMT_VNEXT_PRIMITIVE_COMMAND_HANDOFF_SCHEMA = 'xtend.rmt.vnext.primitive-command-handoff.v1';
+const RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND = 'xtend.rmt.vnext.extractKernelImport';
+const RMT_CODE_ACTION_SCHEMA = 'xtend.rmt.code-action.v1';
+const RMT_WORKSPACE_EDIT_SCHEMA = 'xtend.rmt.workspace-edit.v1';
 
 const VNEXT_COMPLETION_KEYWORDS = Object.freeze([
   ['import', 'Statischen vNext Modulimport deklarieren.'],
@@ -51,6 +60,75 @@ const VNEXT_COMPLETION_KEYWORDS = Object.freeze([
   ['sanitize', 'Sanitize Policy setzen.']
 ]);
 
+const VNEXT_PRIMITIVE_KEYWORDS = Object.freeze([
+  ['state', 'App-State Primitive in vNext deklarieren.'],
+  ['selector', 'Derived Selector aus State oder DataSource ableiten.'],
+  ['datasource', 'DataSource Primitive mit Endpoint, Fixture, SSE oder Worker deklarieren.'],
+  ['action', 'Action Primitive mit Inputs, Reducern, Effects und Emits deklarieren.'],
+  ['portal', 'Portal Root fuer Surface- oder Overlay-Layer deklarieren.'],
+  ['overlay', 'Overlay Primitive wie Toast, Tooltip, Popover, Lightbox, Menu oder Dialog deklarieren.'],
+  ['resource', 'Lifecycle-owned Resource wie Object URL, Stream, Observer, Timer oder Lazy Import deklarieren.'],
+  ['surface', 'Sichtbare oder wiederholbare App-Platform Surface deklarieren.'],
+  ['payload', 'Event-Payload Contract aus DOM-, Detail- oder Surface-Kontext mappen.'],
+  ['destroy releases', 'Surface-Lifecycle an Resource-Teardown binden.']
+]);
+
+const VNEXT_PRIMITIVE_STATE_CLAUSES = Object.freeze([
+  ['type', 'State-Datentyp deklarieren.'],
+  ['preserve', 'State ueber Surface-Lifecycle hinweg erhalten.'],
+  ['initial', 'Initialen State-Wert deklarieren.']
+]);
+
+const VNEXT_PRIMITIVE_SELECTOR_CLAUSES = Object.freeze([
+  ['from state', 'Selector aus State Record ableiten.'],
+  ['from datasource', 'Selector aus DataSource Record ableiten.'],
+  ['where', 'Deklarative Filterbedingung.'],
+  ['find', 'Einzelnen Datensatz deklarativ auswaehlen.'],
+  ['sort by', 'Stabile Sortierung fuer Selector-Ergebnis.'],
+  ['output', 'Selector-Output-Contract deklarieren.']
+]);
+
+const VNEXT_PRIMITIVE_ACTION_CLAUSES = Object.freeze([
+  ['input', 'Typisierten Action-Input deklarieren.'],
+  ['status', 'Status-State fuer Loading, Success und Error binden.'],
+  ['reduce', 'State-Reducer deklarieren.'],
+  ['effect fetch datasource', 'Asynchronen Fetch-Effect gegen eine DataSource deklarieren.'],
+  ['on success -> reduce', 'Success-Result in State schreiben.'],
+  ['on success -> emit', 'Success-Event emittieren.'],
+  ['on error -> overlay', 'Error-Pfad an Overlay-Feedback binden.'],
+  ['emit', 'Typed Event mit Payload deklarieren.']
+]);
+
+const VNEXT_PRIMITIVE_SURFACE_CLAUSES = Object.freeze([
+  ['source selector', 'Surface an Selector-Output binden.'],
+  ['repeat from selector', 'Keyed Surface-Repeater aus Selector-Output erzeugen.'],
+  ['key', 'Stabilen Surface-Key deklarieren.'],
+  ['portal', 'Surface in Portal Root materialisieren.'],
+  ['bounds', 'Initiale Surface-Geometrie deklarieren.'],
+  ['preserve on minimize', 'Surface-State beim Minimieren erhalten.'],
+  ['destroy releases resource', 'Surface-Destroy an Resource-Release koppeln.'],
+  ['lane visible', 'Sichtbare Fabric-Lane fuer Lifecycle-Operation deklarieren.'],
+  ['on click', 'DOM-Event-Binding auf Action deklarieren.'],
+  ['payload', 'Event-Payload Contract mappen.']
+]);
+
+const VNEXT_PRIMITIVE_RESOURCE_KINDS = Object.freeze([
+  ['object-url', 'Object URL Resource mit Revoke-Cleanup.'],
+  ['stream', 'Stream Resource mit owner-scoped Close.'],
+  ['observer', 'Observer Resource mit Disconnect-Cleanup.'],
+  ['timer', 'Timer oder Idle Handle Resource.'],
+  ['lazy-import', 'Lazy Component/Module Import als Host-Adapter-Fakt.']
+]);
+
+const VNEXT_PRIMITIVE_OVERLAY_KINDS = Object.freeze([
+  ['tooltip', 'Viewport-Hint Overlay.'],
+  ['toast', 'Nichtmodales Feedback Overlay.'],
+  ['popover', 'Anchored Interactive Overlay.'],
+  ['lightbox', 'Modaler Media-/Detail-Layer.'],
+  ['menu', 'Keyboard-navigierbares Menu.'],
+  ['dialog', 'Dialog Overlay.']
+]);
+
 const VNEXT_SOURCE_KINDS = Object.freeze([
   ['endpoint', 'Endpoint-basierte Data Source.'],
   ['sse', 'Server-Sent-Events Stream.'],
@@ -110,11 +188,55 @@ const VNEXT_SNIPPETS = Object.freeze([
     body: [
       'on ${1:submit} -> action ${2:settings.save}'
     ]
+  },
+  {
+    id: 'rmt-vnext-primitive-shell',
+    label: 'RMT vNext Primitive Shell',
+    prefix: 'rmt-vnext-primitive-shell',
+    description: 'Granulare App Shell mit State, Selector, Action, Portal, Surface, Lane und Event nur in vNext.',
+    body: [
+      'template ${1:app.shell} {',
+      '  state ${2:app.status} type object preserve {',
+      '    initial {',
+      '      id "${3:status}"',
+      '      text "${4:Ready}"',
+      '    }',
+      '  }',
+      '',
+      '  selector ${2:app.status} from state ${2:app.status} {',
+      '    output ${5:AppStatus}',
+      '  }',
+      '',
+      '  action ${6:app.save} {',
+      '    input label string',
+      '    reduce state.${2:app.status}.text = "${7:Saved}"',
+      '    emit ${8:app.saved} with label input.label',
+      '  }',
+      '',
+      '  portal surface.root root "#${9:app-root}" layer surface',
+      '',
+      '  surface ${10:app.status.card} kind card component ${11:x-status} {',
+      '    source selector ${2:app.status}',
+      '    key status.id',
+      '    portal surface.root',
+      '',
+      '    lane visible weight 50 {',
+      '      hydrate ${12:status-card} from selector ${2:app.status}',
+      '    }',
+      '',
+      '    on click "[data-action=save]" -> action ${6:app.save} {',
+      '      payload label from target.dataset.label',
+      '    }',
+      '  }',
+      '}'
+    ]
   }
 ]);
 
 const DOMAIN_CONFIG = Object.freeze({
   templates: { kind: 'template', label: 'Template', childKind: 'template' },
+  states: { kind: 'state', label: 'State', childKind: 'variable' },
+  selectors: { kind: 'selector', label: 'Selector', childKind: 'function' },
   surfaces: { kind: 'surface', label: 'Surface', childKind: 'namespace' },
   remoteSurfaces: { kind: 'remote-surface', label: 'Remote Surface', childKind: 'namespace' },
   lanes: { kind: 'lane', label: 'Lane', childKind: 'event' },
@@ -122,6 +244,11 @@ const DOMAIN_CONFIG = Object.freeze({
   slots: { kind: 'slot', label: 'Slot', childKind: 'namespace' },
   events: { kind: 'event', label: 'Event', childKind: 'event' },
   dataSources: { kind: 'data-source', label: 'Data Source', childKind: 'interface' },
+  actions: { kind: 'action', label: 'Action', childKind: 'function' },
+  effects: { kind: 'effect', label: 'Effect', childKind: 'function' },
+  portals: { kind: 'portal', label: 'Portal', childKind: 'namespace' },
+  overlays: { kind: 'overlay', label: 'Overlay', childKind: 'namespace' },
+  resources: { kind: 'resource', label: 'Resource', childKind: 'object' },
   securityPolicies: { kind: 'security-policy', label: 'Security Policy', childKind: 'key' }
 });
 
@@ -155,7 +282,7 @@ function isLikelyRmtVNextSource(input = {}, options = {}) {
   }
 
   return /^(?:import|template|surface|remote\s+surface)\b/u.test(trimmed)
-    || /(?:^|\n)\s*(?:remote\s+surface|template|surface|lane|mount|hydrate|update|unmount|stream|slot|on\s+\S+\s+->\s+action|trust\s+boundary|sanitize)\b/u.test(text);
+    || /(?:^|\n)\s*(?:remote\s+surface|template|state|selector|datasource|action|portal|overlay|resource|surface|lane|mount|hydrate|update|unmount|stream|slot|on\s+\S+\s+->\s+action|trust\s+boundary|sanitize)\b/u.test(text);
 }
 
 function sourceRefToRange(sourceMap, sourceRef) {
@@ -203,6 +330,43 @@ function describeRecord(domain, record = {}) {
     return [record.kind || 'source', record.target].filter(Boolean).join(' ');
   }
 
+  if (domain === 'states') {
+    return [record.type || 'state', record.preserve ? 'preserve' : 'ephemeral'].filter(Boolean).join(' - ');
+  }
+
+  if (domain === 'selectors') {
+    return [record.source && record.source.kind || 'source', record.source && record.source.target, record.output ? `output: ${record.output}` : ''].filter(Boolean).join(' ');
+  }
+
+  if (domain === 'actions') {
+    return [
+      `${toArray(record.inputs).length} input(s)`,
+      `${toArray(record.reducers).length} reducer(s)`,
+      `${toArray(record.effectRefs).length} effect(s)`
+    ].join(' - ');
+  }
+
+  if (domain === 'effects') {
+    return [record.kind || 'effect', record.dataSourceRef || record.target].filter(Boolean).join(' ');
+  }
+
+  if (domain === 'portals') {
+    return [record.layer || 'portal', record.root].filter(Boolean).join(' ');
+  }
+
+  if (domain === 'overlays') {
+    return [record.kind || 'overlay', record.portal && record.portal.target ? `portal: ${record.portal.target}` : ''].filter(Boolean).join(' - ');
+  }
+
+  if (domain === 'resources') {
+    const owner = record.owner ? `${record.owner.kind || 'owner'}:${record.owner.id || record.owner.ref || 'unknown'}` : '';
+    return [record.kind || 'resource', owner].filter(Boolean).join(' - ');
+  }
+
+  if (domain === 'surfaces' && record.primitive) {
+    return [record.kind || 'surface', record.component ? `component: ${record.component}` : '', record.source && record.source.target ? `source: ${record.source.target}` : ''].filter(Boolean).join(' - ');
+  }
+
   if (domain === 'securityPolicies') {
     return [record.kind || 'policy', record.boundary || record.format].filter(Boolean).join(' ');
   }
@@ -381,7 +545,7 @@ function lintRmtVNextToolingSource(input = {}, options = {}) {
     graphStatus: analysis.graphStatus,
     coreSchema: analysis.coreSchema,
     sourceMapSummary: analysis.sourceMapSummary,
-    providerCapabilities: ['completion', 'hover', 'symbols', 'definition', 'format'],
+    providerCapabilities: ['completion', 'hover', 'symbols', 'definition', 'codeAction', 'format'],
     diagnostics,
     ruleCount: 0,
     rules: [],
@@ -417,6 +581,12 @@ function staticCompletionItems(entries, base = {}) {
 
 function inferCompletionContext(pointer, explicitContext) {
   if (explicitContext) return explicitContext;
+  if (/^\/states(?:\/|$)/u.test(pointer)) return 'vnext-primitive-state-clauses';
+  if (/^\/selectors(?:\/|$)/u.test(pointer)) return 'vnext-primitive-selector-clauses';
+  if (/^\/actions(?:\/|$)/u.test(pointer)) return 'vnext-primitive-action-clauses';
+  if (/^\/surfaces(?:\/|$)/u.test(pointer)) return 'vnext-primitive-surface-clauses';
+  if (/^\/resources(?:\/|$)/u.test(pointer)) return 'vnext-primitive-resource-kinds';
+  if (/^\/overlays(?:\/|$)/u.test(pointer)) return 'vnext-primitive-overlay-kinds';
   if (/^\/lanes(?:\/|$)/u.test(pointer)) return 'vnext-lanes';
   if (/^\/dataSources(?:\/|$)/u.test(pointer) || /\/source(?:\/|$)/u.test(pointer)) return 'vnext-source-kinds';
   if (/^\/securityPolicies(?:\/|$)/u.test(pointer)) return 'vnext-security';
@@ -424,21 +594,144 @@ function inferCompletionContext(pointer, explicitContext) {
   return 'vnext-keywords';
 }
 
+function normalizePosition(position) {
+  if (!position || !Number.isInteger(position.line)) {
+    return null;
+  }
+
+  return {
+    line: Math.max(0, position.line),
+    character: Number.isInteger(position.character) ? Math.max(0, position.character) : 0
+  };
+}
+
+function getLinePrefixAtPosition(text, position) {
+  const normalized = normalizePosition(position);
+
+  if (!normalized) {
+    return '';
+  }
+
+  const lines = getInputText(text).split(/\r\n|\r|\n/u);
+  const line = lines[normalized.line] || '';
+
+  return line.slice(0, Math.min(normalized.character, line.length));
+}
+
+function inferCompletionPrefixFromLine(linePrefix) {
+  const match = String(linePrefix || '').match(/([A-Za-z0-9_.-]+)$/u);
+  return match ? match[1] : '';
+}
+
+function inferPrimitiveCompletionContextFromLine(linePrefix) {
+  const source = String(linePrefix || '');
+  const trimmed = source.trimStart();
+
+  if (!trimmed) {
+    return 'vnext-primitive-keywords';
+  }
+
+  if (/^resource\b/u.test(trimmed) && /\bkind\s+[A-Za-z0-9_.-]*$/u.test(trimmed)) {
+    return 'vnext-primitive-resource-kinds';
+  }
+
+  if (/^overlay\b/u.test(trimmed) && /\bkind\s+[A-Za-z0-9_.-]*$/u.test(trimmed)) {
+    return 'vnext-primitive-overlay-kinds';
+  }
+
+  if (/^state\b/u.test(trimmed)) {
+    return 'vnext-primitive-state-clauses';
+  }
+
+  if (/^selector\b/u.test(trimmed)) {
+    return 'vnext-primitive-selector-clauses';
+  }
+
+  if (/^action\b/u.test(trimmed) || /^(?:input|status|reduce|effect|emit)\b/u.test(trimmed)) {
+    return 'vnext-primitive-action-clauses';
+  }
+
+  if (/^(?:on\s+(?:success|error)\b|on\s*$)/u.test(trimmed)) {
+    return 'vnext-primitive-action-clauses';
+  }
+
+  if (/^(?:inp|red|eff|emi)[A-Za-z0-9_.-]*$/u.test(trimmed)) {
+    return 'vnext-primitive-action-clauses';
+  }
+
+  if (/^surface\b/u.test(trimmed)) {
+    return 'vnext-primitive-surface-clauses';
+  }
+
+  if (/^(?:source|repeat|key|portal|bounds|preserve|destroy|lane|payload)\b/u.test(trimmed)) {
+    return 'vnext-primitive-surface-clauses';
+  }
+
+  if (/^(?:sta|sel|dat|act|por|ove|res|sur|pay|des)[A-Za-z0-9_.-]*$/u.test(trimmed)) {
+    return 'vnext-primitive-keywords';
+  }
+
+  return null;
+}
+
+function inferPointerAtPosition(analysis, position) {
+  const normalized = normalizePosition(position);
+
+  if (!normalized || !analysis || typeof analysis.findPointerAtPosition !== 'function') {
+    return '';
+  }
+
+  return normalizeString(analysis.findPointerAtPosition(normalized));
+}
+
+function resolveCompletionRequest(input = {}, options = {}, analysis) {
+  const position = normalizePosition(options.position || input.position);
+  const linePrefix = position ? getLinePrefixAtPosition(input, position) : '';
+  const explicitContext = normalizeString(options.context || input.context);
+  const explicitPointer = normalizeString(options.pointer || input.pointer);
+  const pointer = explicitPointer || inferPointerAtPosition(analysis, position);
+  const lineContext = position && !explicitContext ? inferPrimitiveCompletionContextFromLine(linePrefix) : null;
+  const context = explicitContext || lineContext || inferCompletionContext(pointer, null);
+  const explicitPrefix = normalizeString(options.prefix || input.prefix);
+  const prefix = explicitPrefix || (explicitPointer && !lineContext ? '' : inferCompletionPrefixFromLine(linePrefix));
+
+  return {
+    pointer,
+    context,
+    prefix,
+    position,
+    linePrefix
+  };
+}
+
 function sortItems(items) {
   return items.slice().sort((left, right) => String(left.sortText || left.label).localeCompare(String(right.sortText || right.label)));
 }
 
 function getRmtVNextToolingCompletions(input = {}, options = {}) {
   const analysis = options.analysis || analyzeRmtVNextToolingSource(input, options);
-  const pointer = normalizeString(options.pointer || input.pointer);
-  const context = inferCompletionContext(pointer, options.context);
-  const prefix = normalizeString(options.prefix);
+  const request = resolveCompletionRequest(input, options, analysis);
+  const { pointer, context, prefix } = request;
   let items = [];
 
   if (context === 'vnext-lanes') {
     items = staticCompletionItems(VNEXT_LANES, { kind: 'enum', detail: 'vNext Scheduler Lane' });
   } else if (context === 'vnext-source-kinds') {
     items = staticCompletionItems(VNEXT_SOURCE_KINDS, { kind: 'enum', detail: 'vNext Data Source Kind' });
+  } else if (context === 'vnext-primitive-keywords') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_KEYWORDS, { kind: 'keyword', detail: 'vNext App-Platform Primitive' });
+  } else if (context === 'vnext-primitive-state-clauses') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_STATE_CLAUSES, { kind: 'keyword', detail: 'vNext State Clause' });
+  } else if (context === 'vnext-primitive-selector-clauses') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_SELECTOR_CLAUSES, { kind: 'keyword', detail: 'vNext Selector Clause' });
+  } else if (context === 'vnext-primitive-action-clauses') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_ACTION_CLAUSES, { kind: 'keyword', detail: 'vNext Action Clause' });
+  } else if (context === 'vnext-primitive-surface-clauses') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_SURFACE_CLAUSES, { kind: 'keyword', detail: 'vNext Surface Clause' });
+  } else if (context === 'vnext-primitive-resource-kinds') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_RESOURCE_KINDS, { kind: 'enum', detail: 'vNext Resource Kind' });
+  } else if (context === 'vnext-primitive-overlay-kinds') {
+    items = staticCompletionItems(VNEXT_PRIMITIVE_OVERLAY_KINDS, { kind: 'enum', detail: 'vNext Overlay Kind' });
   } else if (context === 'vnext-security') {
     items = staticCompletionItems(VNEXT_TRUST_BOUNDARIES, { kind: 'reference', detail: 'vNext Trust Boundary' })
       .concat(createCompletionItem({
@@ -472,6 +765,8 @@ function getRmtVNextToolingCompletions(input = {}, options = {}) {
     ok: true,
     context,
     prefix,
+    pointer,
+    position: request.position,
     itemCount: filtered.length,
     items: sortItems(filtered),
     graphStatus: analysis.graphStatus,
@@ -660,6 +955,934 @@ function getRmtVNextToolingDefinition(input = {}, options = {}) {
   };
 }
 
+function createTextEdit(range, newText, annotationId = null) {
+  return {
+    range,
+    newText,
+    annotationId
+  };
+}
+
+function createWorkspaceEdit(uri, edits, metadata = {}) {
+  return {
+    schema: RMT_WORKSPACE_EDIT_SCHEMA,
+    changes: {
+      [uri]: edits
+    },
+    metadata
+  };
+}
+
+function createVNextPrimitiveCodeAction(input = {}) {
+  return {
+    schema: RMT_CODE_ACTION_SCHEMA,
+    title: input.title,
+    kind: input.kind || 'quickfix',
+    diagnosticCode: input.diagnosticCode || null,
+    pointer: input.pointer || null,
+    safe: input.safe !== false,
+    confidence: input.confidence || 'high',
+    source: input.source || 'rmt-vnext-primitive-code-actions',
+    diagnostics: toArray(input.diagnostics),
+    edit: input.edit || null,
+    command: input.command || null,
+    preview: input.preview || null,
+    fixAllActionCount: input.fixAllActionCount || null,
+    diagnosticCodes: toArray(input.diagnosticCodes),
+    isPreferred: !!input.isPreferred,
+    workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+  };
+}
+
+function collectWorkspaceEditEntries(edit) {
+  return Object.entries(edit && edit.changes ? edit.changes : {}).flatMap(([uri, edits]) => (
+    toArray(edits).map((entry, index) => ({
+      uri,
+      edit: entry,
+      index
+    }))
+  ));
+}
+
+function workspaceEditUris(edit) {
+  return Array.from(new Set(collectWorkspaceEditEntries(edit).map((entry) => entry.uri))).sort();
+}
+
+function applyWorkspaceEditToText(text, edit, uri) {
+  const sourceModel = createRmtSourceModel({
+    text,
+    uri: uri || 'untitled:rmt-document'
+  });
+  const patches = collectWorkspaceEditEntries(edit)
+    .filter((entry) => !uri || entry.uri === uri)
+    .map((entry) => {
+      const range = entry.edit && entry.edit.range;
+      return {
+        ...entry,
+        start: range ? sourceModel.offsetAt(range.start) : 0,
+        end: range ? sourceModel.offsetAt(range.end) : 0,
+        newText: entry.edit && typeof entry.edit.newText === 'string' ? entry.edit.newText : ''
+      };
+    })
+    .sort((left, right) => {
+      if (left.start !== right.start) return right.start - left.start;
+      if (left.end !== right.end) return right.end - left.end;
+      return right.index - left.index;
+    });
+  let nextText = text;
+
+  patches.forEach((patch) => {
+    nextText = `${nextText.slice(0, patch.start)}${patch.newText}${nextText.slice(patch.end)}`;
+  });
+
+  return nextText;
+}
+
+function summarizePreviewLines(beforeText, afterText) {
+  const beforeLines = String(beforeText || '').split(/\r\n|\r|\n/u);
+  const afterLines = String(afterText || '').split(/\r\n|\r|\n/u);
+  const max = Math.max(beforeLines.length, afterLines.length);
+  let firstChangedLine = -1;
+
+  for (let index = 0; index < max; index += 1) {
+    if ((beforeLines[index] || '') !== (afterLines[index] || '')) {
+      firstChangedLine = index;
+      break;
+    }
+  }
+
+  if (firstChangedLine < 0) {
+    return {
+      changedLineCount: 0,
+      firstChangedLine: null,
+      before: [],
+      after: []
+    };
+  }
+
+  let changedLineCount = 0;
+  for (let index = firstChangedLine; index < max; index += 1) {
+    if ((beforeLines[index] || '') !== (afterLines[index] || '')) {
+      changedLineCount += 1;
+    }
+  }
+
+  const end = firstChangedLine + 8;
+  return {
+    changedLineCount,
+    firstChangedLine,
+    before: beforeLines.slice(firstChangedLine, end),
+    after: afterLines.slice(firstChangedLine, end)
+  };
+}
+
+function createWorkspaceEditPreview(analysis, action, edit) {
+  const sourceModel = analysis && analysis.sourceModel;
+  const entries = collectWorkspaceEditEntries(edit);
+  const affectedUris = workspaceEditUris(edit);
+  const uri = sourceModel && sourceModel.uri;
+  const localEntries = uri ? entries.filter((entry) => entry.uri === uri) : [];
+  const status = localEntries.length > 0 ? 'ready' : entries.length > 0 ? 'external-uri' : 'empty';
+  const beforeText = sourceModel ? sourceModel.text : '';
+  const afterText = localEntries.length > 0
+    ? applyWorkspaceEditToText(beforeText, {
+      schema: RMT_WORKSPACE_EDIT_SCHEMA,
+      changes: {
+        [uri]: localEntries.map((entry) => entry.edit)
+      }
+    }, uri)
+    : beforeText;
+  const summary = summarizePreviewLines(beforeText, afterText);
+
+  return {
+    schema: RMT_VNEXT_PRIMITIVE_CODE_ACTION_PREVIEW_SCHEMA,
+    status,
+    title: action && action.title ? action.title : null,
+    kind: action && action.kind ? action.kind : 'quickfix',
+    diagnosticCode: action && action.diagnosticCode ? action.diagnosticCode : null,
+    safe: !(action && action.safe === false),
+    uri: uri || null,
+    affectedUris,
+    editCount: entries.length,
+    localEditCount: localEntries.length,
+    changedLineCount: summary.changedLineCount,
+    firstChangedLine: summary.firstChangedLine,
+    before: summary.before,
+    after: summary.after,
+    repairKind: edit && edit.metadata ? edit.metadata.repairKind || null : null,
+    workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+  };
+}
+
+function attachVNextPrimitiveActionPreview(analysis, action) {
+  if (!action) {
+    return null;
+  }
+
+  if (!action.edit) {
+    return {
+      ...action,
+      preview: {
+        schema: RMT_VNEXT_PRIMITIVE_CODE_ACTION_PREVIEW_SCHEMA,
+        status: action.command ? 'manual-command' : 'empty',
+        title: action.title || null,
+        kind: action.kind || 'quickfix',
+        diagnosticCode: action.diagnosticCode || null,
+        safe: action.safe !== false,
+        uri: analysis && analysis.sourceModel ? analysis.sourceModel.uri : null,
+        affectedUris: [],
+        editCount: 0,
+        localEditCount: 0,
+        changedLineCount: 0,
+        firstChangedLine: null,
+        before: [],
+        after: [],
+        repairKind: null,
+        workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+      }
+    };
+  }
+
+  return {
+    ...action,
+    preview: createWorkspaceEditPreview(analysis, action, action.edit)
+  };
+}
+
+function rangeAtOffset(sourceModel, offset) {
+  if (!sourceModel || typeof sourceModel.rangeForOffsets !== 'function') {
+    return null;
+  }
+
+  return sourceModel.rangeForOffsets(offset, offset);
+}
+
+function lineIndent(sourceModel, line) {
+  const text = sourceModel && typeof sourceModel.lineText === 'function'
+    ? sourceModel.lineText(line)
+    : '';
+  return (text.match(/^\s*/u) || [''])[0];
+}
+
+function lineEndInsertRange(sourceModel, line) {
+  if (!sourceModel || typeof sourceModel.lineRange !== 'function') {
+    return null;
+  }
+
+  const lineRange = sourceModel.lineRange(line);
+  return lineRange && Number.isInteger(lineRange.endOffset)
+    ? rangeAtOffset(sourceModel, lineRange.endOffset)
+    : null;
+}
+
+function createLineEndInsertAction(analysis, diagnostic, newText, title, metadata = {}) {
+  const sourceModel = analysis.sourceModel;
+  const range = diagnostic.range || null;
+  const line = range && range.start ? range.start.line : 0;
+  const insertRange = lineEndInsertRange(sourceModel, line);
+
+  if (!insertRange || !sourceModel || !sourceModel.uri) {
+    return null;
+  }
+
+  return createVNextPrimitiveCodeAction({
+    title,
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(insertRange, newText, metadata.annotationId || `vnext-${diagnostic.code}`)
+    ], {
+      repairKind: metadata.repairKind || 'insert-vnext-primitive-clause',
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE,
+      ...metadata
+    }),
+    isPreferred: metadata.isPreferred !== false
+  });
+}
+
+function getVNextPrimitiveSemanticGraph(analysis) {
+  return analysis
+    && analysis.compileResult
+    && analysis.compileResult.primitiveSemanticGraph
+    ? analysis.compileResult.primitiveSemanticGraph
+    : null;
+}
+
+function getFirstCatalogId(analysis, key, fallbackDomain) {
+  const semanticGraph = getVNextPrimitiveSemanticGraph(analysis);
+  const hints = semanticGraph && semanticGraph.catalogHints || {};
+  const fromHints = toArray(hints[key])[0];
+
+  if (fromHints) {
+    return fromHints;
+  }
+
+  const index = analysis && analysis.indexes && analysis.indexes[fallbackDomain];
+  return index && index.ids ? index.ids[0] || '' : '';
+}
+
+function selectPrimitiveOwner(analysis) {
+  const surfaceId = getFirstCatalogId(analysis, 'surfaceIds', 'surfaces');
+
+  if (surfaceId) {
+    return {
+      kind: 'surface',
+      id: surfaceId
+    };
+  }
+
+  const overlayId = getFirstCatalogId(analysis, 'overlayIds', 'overlays');
+
+  if (overlayId) {
+    return {
+      kind: 'overlay',
+      id: overlayId
+    };
+  }
+
+  return null;
+}
+
+function createResourceOwnerAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+  const owner = selectPrimitiveOwner(analysis);
+  const line = diagnostic.range && diagnostic.range.start ? diagnostic.range.start.line : 0;
+  const lineText = sourceModel && typeof sourceModel.lineText === 'function' ? sourceModel.lineText(line) : '';
+  const ownerText = owner ? `${owner.kind}.${owner.id}` : '';
+
+  if (!sourceModel || !sourceModel.uri || !ownerText || !/\bresource\b/u.test(lineText)) {
+    return null;
+  }
+
+  const lineRange = sourceModel.lineRange(line);
+  const braceIndex = lineText.indexOf('{');
+  const insertOffset = braceIndex >= 0
+    ? lineRange.startOffset + braceIndex
+    : lineRange.endOffset;
+  const insertText = braceIndex >= 0
+    ? `owner ${ownerText} `
+    : ` owner ${ownerText}`;
+  const insertRange = rangeAtOffset(sourceModel, insertOffset);
+
+  if (!insertRange) {
+    return null;
+  }
+
+  return createVNextPrimitiveCodeAction({
+    title: `Resource owner auf ${ownerText} setzen`,
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(insertRange, insertText, `vnext-owner-${diagnostic.code}`)
+    ], {
+      repairKind: 'add-resource-owner',
+      owner: ownerText,
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }),
+    isPreferred: true
+  });
+}
+
+function createSurfaceKeyAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+  const line = diagnostic.range && diagnostic.range.start ? diagnostic.range.start.line : 0;
+  const indent = lineIndent(sourceModel, line);
+
+  return createLineEndInsertAction(
+    analysis,
+    diagnostic,
+    `\n${indent}key instance.id`,
+    'Surface key-Klausel ergaenzen',
+    {
+      repairKind: 'add-surface-key-clause',
+      insertedClause: 'key instance.id'
+    }
+  );
+}
+
+function createPayloadContractAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+  const line = diagnostic.range && diagnostic.range.start ? diagnostic.range.start.line : 0;
+  const text = sourceModel && typeof sourceModel.lineText === 'function' ? sourceModel.lineText(line) : '';
+  const trimmed = text.trim();
+  const indent = lineIndent(sourceModel, line);
+  const newText = /^emit\b/u.test(trimmed)
+    ? ' with value input.value'
+    : trimmed.endsWith('{')
+      ? `\n${indent}  payload id from target.dataset.id`
+      : ` {\n${indent}  payload id from target.dataset.id\n${indent}}`;
+
+  return createLineEndInsertAction(
+    analysis,
+    diagnostic,
+    newText,
+    'Event Payload Contract ergaenzen',
+    {
+      repairKind: 'add-event-payload-contract',
+      insertedClause: /^emit\b/u.test(trimmed) ? 'with value input.value' : 'payload id from target.dataset.id'
+    }
+  );
+}
+
+function findAstNodeByPointer(node, pointer) {
+  if (!node || typeof node !== 'object' || !pointer) {
+    return null;
+  }
+
+  if (node.astPointer === pointer) {
+    return node;
+  }
+
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        const match = findAstNodeByPointer(entry, pointer);
+        if (match) return match;
+      }
+    } else if (value && typeof value === 'object') {
+      const match = findAstNodeByPointer(value, pointer);
+      if (match) return match;
+    }
+  }
+
+  return null;
+}
+
+function findTemplateChildForPointer(ast, pointer) {
+  const templates = toArray(ast && ast.body).filter((entry) => entry && entry.type === 'RmtTemplateDeclaration');
+
+  for (const template of templates) {
+    for (const child of toArray(template.body)) {
+      if (child && child.astPointer && pointer.startsWith(child.astPointer)) {
+        return child;
+      }
+    }
+  }
+
+  return null;
+}
+
+function insertRangeBeforeTemplateChild(analysis, pointer) {
+  const sourceModel = analysis.sourceModel;
+  const child = findTemplateChildForPointer(analysis.ast, pointer);
+
+  if (!sourceModel || !child || !child.range || !child.range.start) {
+    return null;
+  }
+
+  const lineRange = sourceModel.lineRange(child.range.start.line);
+  return {
+    range: rangeAtOffset(sourceModel, lineRange.startOffset),
+    indent: lineIndent(sourceModel, child.range.start.line)
+  };
+}
+
+function getReferenceForDiagnostic(analysis, diagnostic) {
+  const semanticGraph = getVNextPrimitiveSemanticGraph(analysis);
+  return semanticGraph && typeof semanticGraph.findReferenceAtPointer === 'function'
+    ? semanticGraph.findReferenceAtPointer(diagnostic.pointer)
+    : null;
+}
+
+function createSelectorStubAction(analysis, diagnostic, reference) {
+  const sourceModel = analysis.sourceModel;
+  const insertion = insertRangeBeforeTemplateChild(analysis, diagnostic.pointer);
+  const targetId = normalizeString(reference && reference.targetId);
+  const stateId = getFirstCatalogId(analysis, 'stateIds', 'states') || 'app.state';
+
+  if (!sourceModel || !sourceModel.uri || !insertion || !targetId) {
+    return null;
+  }
+
+  const selectorText = `${insertion.indent}selector ${targetId} from state ${stateId} {\n${insertion.indent}  output GeneratedRecord[]\n${insertion.indent}}\n\n`;
+
+  return createVNextPrimitiveCodeAction({
+    title: `Selector "${targetId}" anlegen`,
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(insertion.range, selectorText, `vnext-selector-${targetId}`)
+    ], {
+      repairKind: 'create-selector-stub',
+      targetDomain: 'selectors',
+      targetId,
+      dedupeKey: `selectors:${targetId}`,
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }),
+    isPreferred: true
+  });
+}
+
+function createPortalStubAction(analysis, diagnostic, reference) {
+  const sourceModel = analysis.sourceModel;
+  const insertion = insertRangeBeforeTemplateChild(analysis, diagnostic.pointer);
+  const targetId = normalizeString(reference && reference.targetId);
+  const rootId = targetId ? targetId.replace(/[^A-Za-z0-9_-]+/gu, '-').replace(/^-+|-+$/gu, '') : 'generated-portal';
+
+  if (!sourceModel || !sourceModel.uri || !insertion || !targetId) {
+    return null;
+  }
+
+  const portalText = `${insertion.indent}portal ${targetId} root "#${rootId || 'generated-portal'}" layer surface\n\n`;
+
+  return createVNextPrimitiveCodeAction({
+    title: `Portal "${targetId}" anlegen`,
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(insertion.range, portalText, `vnext-portal-${targetId}`)
+    ], {
+      repairKind: 'create-portal-stub',
+      targetDomain: 'portals',
+      targetId,
+      dedupeKey: `portals:${targetId}`,
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }),
+    isPreferred: true
+  });
+}
+
+function createUnknownReferenceAction(analysis, diagnostic) {
+  const reference = getReferenceForDiagnostic(analysis, diagnostic);
+
+  if (!reference || reference.resolved) {
+    return null;
+  }
+
+  if (reference.targetDomain === 'selectors') {
+    return createSelectorStubAction(analysis, diagnostic, reference);
+  }
+
+  if (reference.targetDomain === 'portals') {
+    return createPortalStubAction(analysis, diagnostic, reference);
+  }
+
+  return null;
+}
+
+function defaultInitialForState(node) {
+  const typeValue = normalizeString(node && node.dataType && node.dataType.value).toLowerCase();
+
+  if (typeValue.includes('[]')) {
+    return '[]';
+  }
+
+  if (typeValue.includes('boolean')) {
+    return 'false';
+  }
+
+  if (typeValue.includes('number') || typeValue.includes('int') || typeValue.includes('float')) {
+    return '0';
+  }
+
+  if (typeValue.includes('string')) {
+    return '""';
+  }
+
+  return '';
+}
+
+function createStateInitialAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+  const node = findAstNodeByPointer(analysis.ast, diagnostic.pointer);
+  const line = diagnostic.range && diagnostic.range.start ? diagnostic.range.start.line : 0;
+  const text = sourceModel && typeof sourceModel.lineText === 'function' ? sourceModel.lineText(line) : '';
+  const indent = lineIndent(sourceModel, line);
+  const lineRange = sourceModel && typeof sourceModel.lineRange === 'function' ? sourceModel.lineRange(line) : null;
+  const initialValue = defaultInitialForState(node);
+
+  if (!sourceModel || !sourceModel.uri || !lineRange) {
+    return null;
+  }
+
+  let newText = initialValue ? ` initial ${initialValue}` : ` {\n${indent}  initial {}\n${indent}}`;
+
+  if (text.includes('{')) {
+    newText = `\n${indent}  initial {}`;
+  }
+
+  return createVNextPrimitiveCodeAction({
+    title: 'State initial-Wert ergaenzen',
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(rangeAtOffset(sourceModel, lineRange.endOffset), newText, `vnext-initial-${diagnostic.code}`)
+    ], {
+      repairKind: 'add-state-initial',
+      insertedClause: initialValue ? `initial ${initialValue}` : 'initial {}',
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }),
+    isPreferred: true
+  });
+}
+
+function createResourceKindAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+  const line = diagnostic.range && diagnostic.range.start ? diagnostic.range.start.line : 0;
+  const text = sourceModel && typeof sourceModel.lineText === 'function' ? sourceModel.lineText(line) : '';
+  const lineRange = sourceModel && typeof sourceModel.lineRange === 'function' ? sourceModel.lineRange(line) : null;
+  const match = text.match(/^(\s*resource\s+\S+\s*)/u);
+
+  if (!sourceModel || !sourceModel.uri || !lineRange || !match) {
+    return null;
+  }
+
+  return createVNextPrimitiveCodeAction({
+    title: 'Resource kind auf object-url setzen',
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(rangeAtOffset(sourceModel, lineRange.startOffset + match[1].length), 'kind object-url ', `vnext-kind-${diagnostic.code}`)
+    ], {
+      repairKind: 'add-resource-kind',
+      resourceKind: 'object-url',
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }),
+    isPreferred: true
+  });
+}
+
+function insertRangeBeforeNodeEnd(analysis, node) {
+  const sourceModel = analysis.sourceModel;
+
+  if (!sourceModel || !node || !node.range || !node.range.end) {
+    return null;
+  }
+
+  const lineRange = sourceModel.lineRange(node.range.end.line);
+
+  return {
+    range: rangeAtOffset(sourceModel, lineRange.startOffset),
+    closingIndent: lineIndent(sourceModel, node.range.end.line)
+  };
+}
+
+function firstActionInputName(node) {
+  const input = toArray(node && node.body).find((entry) => entry && entry.type === 'RmtActionInputClause' && entry.name);
+  return normalizeString(input && input.name);
+}
+
+function createActionReducerAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+  const node = findAstNodeByPointer(analysis.ast, diagnostic.pointer);
+  const insertion = insertRangeBeforeNodeEnd(analysis, node);
+  const stateId = getFirstCatalogId(analysis, 'stateIds', 'states') || 'app.state';
+  const inputName = firstActionInputName(node);
+  const expression = inputName ? `input.${inputName}` : `state.${stateId}`;
+
+  if (!sourceModel || !sourceModel.uri || !insertion) {
+    return null;
+  }
+
+  return createVNextPrimitiveCodeAction({
+    title: `Action Reducer-Ziel auf state.${stateId} setzen`,
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    edit: createWorkspaceEdit(sourceModel.uri, [
+      createTextEdit(
+        insertion.range,
+        `${insertion.closingIndent}  reduce state.${stateId} = ${expression}\n`,
+        `vnext-action-reducer-${diagnostic.code}`
+      )
+    ], {
+      repairKind: 'add-action-reducer-target',
+      stateId,
+      inputName: inputName || null,
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }),
+    isPreferred: true
+  });
+}
+
+function createEffectSourceAction(analysis, diagnostic) {
+  const dataSourceId = getFirstCatalogId(analysis, 'dataSourceIds', 'dataSources') || 'generated.datasource';
+
+  return createLineEndInsertAction(
+    analysis,
+    diagnostic,
+    ` datasource ${dataSourceId}`,
+    `Effect-Quelle datasource ${dataSourceId} ergaenzen`,
+    {
+      repairKind: 'add-effect-source',
+      targetDomain: 'dataSources',
+      targetId: dataSourceId
+    }
+  );
+}
+
+function createKernelBoundaryCommandAction(analysis, diagnostic) {
+  const sourceModel = analysis.sourceModel;
+
+  return createVNextPrimitiveCodeAction({
+    title: 'Kernel/Fabric Import in Host-Adapter auslagern',
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    diagnostics: [diagnostic],
+    safe: false,
+    confidence: 'manual',
+    command: {
+      title: 'Kernel/Fabric Import in Host-Adapter auslagern',
+      command: RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND,
+      arguments: [{
+        uri: sourceModel ? sourceModel.uri : null,
+        pointer: diagnostic.pointer || null,
+        diagnosticCode: diagnostic.code,
+        reason: 'kernel-fabric-boundary'
+      }]
+    },
+    isPreferred: false
+  });
+}
+
+function createRmtVNextPrimitiveCommandHandoff(input = {}, options = {}) {
+  const command = normalizeString(input.command || options.command);
+  const args = toArray(input.arguments || options.arguments);
+  const firstArg = args[0] && typeof args[0] === 'object' ? args[0] : {};
+  const pointer = normalizeString(input.pointer || firstArg.pointer || options.pointer);
+  const uri = normalizeString(input.uri || firstArg.uri || options.uri);
+  const diagnosticCode = normalizeString(input.diagnosticCode || firstArg.diagnosticCode || options.diagnosticCode);
+  const supported = command === RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND;
+
+  return {
+    schema: RMT_VNEXT_PRIMITIVE_COMMAND_HANDOFF_SCHEMA,
+    workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE,
+    languageMode: 'vnext',
+    status: supported ? 'manual_handoff' : 'unsupported_command',
+    ok: supported,
+    command,
+    uri: uri || null,
+    pointer: pointer || null,
+    diagnosticCode: diagnosticCode || null,
+    safe: false,
+    edit: null,
+    commandKind: supported ? 'kernel-boundary-extraction' : null,
+    boundary: 'no-kernel-fabric-imports-in-vnext-source',
+    hostAdapterTarget: 'xtend-rmt-host-adapter',
+    manualSteps: supported ? [
+      'Move Kernel/Fabric imports out of the vNext source file.',
+      'Expose the runtime dependency through a host adapter or scaffold/runtime boundary.',
+      'Keep RMT vNext source limited to primitive declarations and host-neutral references.',
+      'Re-run node scripts/run_xtend_tests.js rmt-vnext-tooling --json and the primitive aggregate gate.'
+    ] : [],
+    reason: normalizeString(input.reason || firstArg.reason || options.reason) || null
+  };
+}
+
+function createVNextPrimitiveActionForDiagnostic(analysis, diagnostic) {
+  if (!diagnostic || !diagnostic.code) {
+    return null;
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.owner-missing') {
+    return createResourceOwnerAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.unkeyed-repeat') {
+    return createSurfaceKeyAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.payload-contract-missing') {
+    return createPayloadContractAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.unknown-reference') {
+    return createUnknownReferenceAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.initial-missing') {
+    return createStateInitialAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.resource-kind-missing') {
+    return createResourceKindAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.action-reducer-missing') {
+    return createActionReducerAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.effect-source-missing') {
+    return createEffectSourceAction(analysis, diagnostic);
+  }
+
+  if (diagnostic.code === 'rmt.vnext.primitive.kernel-boundary') {
+    return createKernelBoundaryCommandAction(analysis, diagnostic);
+  }
+
+  return null;
+}
+
+function actionKey(action) {
+  if (!action) {
+    return '';
+  }
+
+  const dedupeKey = action.edit && action.edit.metadata && action.edit.metadata.dedupeKey;
+
+  if (dedupeKey) {
+    return `${action.diagnosticCode}:${dedupeKey}`;
+  }
+
+  const edit = action.edit ? JSON.stringify(action.edit) : '';
+  const command = action.command ? JSON.stringify(action.command) : '';
+
+  return `${action.title}:${action.diagnosticCode}:${edit}:${command}`;
+}
+
+function uniqueAndSortActions(actions) {
+  const seen = new Set();
+  const result = [];
+
+  actions.filter(Boolean).forEach((action) => {
+    const key = actionKey(action);
+
+    if (seen.has(key)) {
+      return;
+    }
+
+    seen.add(key);
+    result.push(action);
+  });
+
+  return result.sort((left, right) => {
+    const codeDiff = String(left.diagnosticCode || '').localeCompare(String(right.diagnosticCode || ''));
+    return codeDiff !== 0 ? codeDiff : String(left.title || '').localeCompare(String(right.title || ''));
+  });
+}
+
+function mergeWorkspaceEdits(actions) {
+  const changes = {};
+  const repairKinds = [];
+  const diagnosticCodes = [];
+
+  toArray(actions).forEach((action) => {
+    if (!action || !action.edit || action.safe === false) {
+      return;
+    }
+
+    const metadata = action.edit.metadata || {};
+
+    if (metadata.repairKind) {
+      repairKinds.push(metadata.repairKind);
+    }
+
+    if (action.diagnosticCode) {
+      diagnosticCodes.push(action.diagnosticCode);
+    }
+
+    collectWorkspaceEditEntries(action.edit).forEach((entry) => {
+      if (!changes[entry.uri]) {
+        changes[entry.uri] = [];
+      }
+
+      changes[entry.uri].push(entry.edit);
+    });
+  });
+
+  return {
+    schema: RMT_WORKSPACE_EDIT_SCHEMA,
+    changes,
+    metadata: {
+      repairKind: 'apply-all-safe-vnext-primitive-code-actions',
+      actionCount: toArray(actions).filter((action) => action && action.edit && action.safe !== false).length,
+      diagnosticCodes: Array.from(new Set(diagnosticCodes)).sort(),
+      repairKinds: Array.from(new Set(repairKinds)).sort(),
+      workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE
+    }
+  };
+}
+
+function createVNextPrimitiveFixAllAction(analysis, actions) {
+  const safeActions = toArray(actions).filter((action) => action && action.edit && action.safe !== false);
+
+  if (safeActions.length < 2) {
+    return null;
+  }
+
+  const diagnosticCodes = Array.from(new Set(safeActions.map((action) => action.diagnosticCode).filter(Boolean))).sort();
+
+  return createVNextPrimitiveCodeAction({
+    title: `Alle sicheren vNext-Primitive Quick-Fixes anwenden (${safeActions.length})`,
+    kind: RMT_VNEXT_PRIMITIVE_FIX_ALL_KIND,
+    diagnosticCode: 'rmt.vnext.primitive.fix-all-safe',
+    pointer: null,
+    diagnostics: safeActions.flatMap((action) => toArray(action.diagnostics)),
+    edit: mergeWorkspaceEdits(safeActions),
+    confidence: 'high',
+    source: 'rmt-vnext-primitive-fix-all',
+    isPreferred: false,
+    preview: null,
+    safe: true,
+    fixAllActionCount: safeActions.length,
+    diagnosticCodes
+  });
+}
+
+function normalizeDiagnosticFilters(diagnostics) {
+  return toArray(diagnostics).map((diagnostic) => ({
+    code: diagnostic.code || null,
+    pointer: diagnostic.pointer || (diagnostic.data && diagnostic.data.pointer) || null
+  }));
+}
+
+function shouldIncludeDiagnostic(diagnostic, filters) {
+  if (filters.length === 0) {
+    return true;
+  }
+
+  return filters.some((filter) => {
+    const codeMatches = !filter.code || filter.code === diagnostic.code;
+    const pointerMatches = !filter.pointer || filter.pointer === diagnostic.pointer;
+
+    return codeMatches && pointerMatches;
+  });
+}
+
+function getRmtVNextToolingCodeActions(input = {}, options = {}) {
+  const analysis = options.analysis || analyzeRmtVNextToolingSource(input, options);
+  const diagnostics = toArray(options.diagnostics || options.contextDiagnostics).length > 0
+    ? toArray(analysis.diagnostics).filter((diagnostic) => shouldIncludeDiagnostic(
+      diagnostic,
+      normalizeDiagnosticFilters(options.diagnostics || options.contextDiagnostics)
+    ))
+    : toArray(analysis.diagnostics);
+  const quickFixActions = uniqueAndSortActions(diagnostics.map((diagnostic) => createVNextPrimitiveActionForDiagnostic(analysis, diagnostic)))
+    .map((action) => attachVNextPrimitiveActionPreview(analysis, action));
+  const fixAllAction = attachVNextPrimitiveActionPreview(
+    analysis,
+    createVNextPrimitiveFixAllAction(analysis, quickFixActions)
+  );
+  const actions = fixAllAction ? [fixAllAction].concat(quickFixActions) : quickFixActions;
+  const previews = actions.map((action) => action && action.preview).filter(Boolean);
+
+  return {
+    schema: RMT_VNEXT_PRIMITIVE_CODE_ACTION_REPORT_SCHEMA,
+    providerSchema: RMT_VNEXT_PRIMITIVE_CODE_ACTION_PROVIDER_SCHEMA,
+    previewSchema: RMT_VNEXT_PRIMITIVE_CODE_ACTION_PREVIEW_SCHEMA,
+    actionSchema: RMT_CODE_ACTION_SCHEMA,
+    editSchema: RMT_WORKSPACE_EDIT_SCHEMA,
+    workpackage: RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE,
+    languageMode: 'vnext',
+    status: analysis.sourceModel ? 'completed' : 'source_unavailable',
+    ok: !!analysis.sourceModel,
+    actionCount: actions.length,
+    quickFixCount: quickFixActions.length,
+    fixAllCount: fixAllAction ? 1 : 0,
+    previewCount: previews.length,
+    actions,
+    diagnosticCount: diagnostics.length,
+    graphStatus: analysis.graphStatus,
+    sourceMapSummary: analysis.sourceMapSummary
+  };
+}
+
 function formatRmtVNextSource(input = {}, options = {}) {
   const text = getInputText(input);
   const analysis = options.analysis || analyzeRmtVNextToolingSource(input, options);
@@ -698,27 +1921,46 @@ function createRmtVNextToolingAdapter(defaultOptions = {}) {
     hover: (input = {}, options = {}) => getRmtVNextToolingHover(input, { ...defaultOptions, ...options }),
     documentSymbols: (input = {}, options = {}) => getRmtVNextToolingDocumentSymbols(input, { ...defaultOptions, ...options }),
     definition: (input = {}, options = {}) => getRmtVNextToolingDefinition(input, { ...defaultOptions, ...options }),
+    codeActions: (input = {}, options = {}) => getRmtVNextToolingCodeActions(input, { ...defaultOptions, ...options }),
     format: (input = {}, options = {}) => formatRmtVNextSource(input, { ...defaultOptions, ...options })
   });
 }
 
 module.exports = {
+  RMT_CODE_ACTION_SCHEMA,
+  RMT_WORKSPACE_EDIT_SCHEMA,
+  RMT_VNEXT_PRIMITIVE_CODE_ACTION_PROVIDER_SCHEMA,
+  RMT_VNEXT_PRIMITIVE_CODE_ACTION_PREVIEW_SCHEMA,
+  RMT_VNEXT_PRIMITIVE_CODE_ACTION_REPORT_SCHEMA,
+  RMT_VNEXT_PRIMITIVE_COMMAND_HANDOFF_SCHEMA,
+  RMT_VNEXT_PRIMITIVE_FIX_ALL_KIND,
+  RMT_VNEXT_PRIMITIVE_KERNEL_BOUNDARY_COMMAND,
   RMT_VNEXT_TOOLING_FORMATTER_SCHEMA,
   RMT_VNEXT_TOOLING_MODULE_PATH,
   RMT_VNEXT_TOOLING_PACKAGE_SCRIPT,
+  RMT_VNEXT_PRIMITIVE_AUTHORING_WORKPACKAGE,
   RMT_VNEXT_TOOLING_REPORT_SCHEMA,
   RMT_VNEXT_TOOLING_SCHEMA,
   RMT_VNEXT_TOOLING_SUITE_PATH,
   RMT_VNEXT_TOOLING_WORKPACKAGE,
   VNEXT_COMPLETION_KEYWORDS,
   VNEXT_LANES,
+  VNEXT_PRIMITIVE_ACTION_CLAUSES,
+  VNEXT_PRIMITIVE_KEYWORDS,
+  VNEXT_PRIMITIVE_OVERLAY_KINDS,
+  VNEXT_PRIMITIVE_RESOURCE_KINDS,
+  VNEXT_PRIMITIVE_SELECTOR_CLAUSES,
+  VNEXT_PRIMITIVE_STATE_CLAUSES,
+  VNEXT_PRIMITIVE_SURFACE_CLAUSES,
   VNEXT_SNIPPETS,
   VNEXT_SOURCE_KINDS,
   VNEXT_TRUST_BOUNDARIES,
   analyzeRmtVNextToolingSource,
   createRmtVNextToolingAdapter,
+  createRmtVNextPrimitiveCommandHandoff,
   findRmtVNextPointerAtPosition,
   formatRmtVNextSource,
+  getRmtVNextToolingCodeActions,
   getRmtVNextToolingCompletions,
   getRmtVNextToolingDefinition,
   getRmtVNextToolingDocumentSymbols,