@ccslabs/xtend 0.1.0-rc.1 → 0.1.2

package/catalog/epic18-rmt-surface-resource-graph-runtime.js

@@ -0,0 +1,256 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+const {
+  RMT_ACTION_EFFECT_RUNTIME_SCHEMA,
+  RMT_ACTION_EFFECT_RUNTIME_WORKPACKAGE
+} = require('./epic18-rmt-action-effect-runtime');
+const {
+  RMT_EVENT_ROUTING_RUNTIME_SCHEMA,
+  RMT_EVENT_ROUTING_RUNTIME_WORKPACKAGE
+} = require('./epic18-rmt-event-routing-runtime');
+
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SCHEMA = 'xtend.epic18.rmt-surface-resource-graph-runtime.v1';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA = 'xtend.epic18.rmt-surface-resource-graph-runtime-report.v1';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE_SCHEMA = 'xtend.epic18.rmt-surface-resource-graph-runtime-fixture.v1';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE = 'WP-E18-10';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_STATUS = 'accepted-surface-overlay-portal-resource-graph-runtime';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TARGET = 'surface-overlay-portal-resource-graph-ready';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_MODULE = 'catalog/epic18-rmt-surface-resource-graph-runtime.js';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_RUNTIME = 'xtendrmt/rmt-surface-resource-graph-runtime.js';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TYPES = 'xtendrmt/rmt-surface-resource-graph-runtime.d.ts';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SUITE = 'tests/rmt/rmt_surface_resource_graph_runtime_suite.js';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE = 'tests/fixtures/rmt-surface-resource-graph-runtime.rmt';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_DOCS = 'docs/rmt-surface-resource-graph-runtime.md';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE_DOC = 'development/WP-E18-10-Surface-Overlay-Portal-und-Resource-Graph-generisch-haerten.md';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_BACKLOG = 'development/BACKLOG-EPIC-18-XTendRMT-App-Platform-und-Media-Manager-Vendor-Upstream.md';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_EPIC = 'docs/epic18-media-manager-vendor-upstream.md';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_LOCAL_GATE = 'node scripts/run_xtend_tests.js rmt-surface-resource-graph-runtime --json';
+const RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_PACKAGE_SCRIPT = 'npm run test:rmt-surface-resource-graph-runtime';
+const NEXT_WORKPACKAGE = 'WP-E18-11';
+const NEXT_DECISION = 'scaffold-linter-lsp-diagnostics-for-rmt-apps';
+
+const REQUIRED_SURFACE_CAPABILITIES = Object.freeze([
+  'keyed-surface-repeater',
+  'bounds-focus-close-destroy-minimize-restore',
+  'surface-persistence',
+  'portal-layer-stack',
+  'overlay-policy-tooltip-toast-popover-lightbox-menu-dialog',
+  'resource-cleanup-per-instance',
+  'event-owner-detach-on-destroy',
+  'minimize-preserves-dom-state',
+  'destroy-releases-owned-resources',
+  'diagnostics'
+]);
+
+const REQUIRED_SURFACE_KINDS = Object.freeze([
+  'workspace',
+  'panel',
+  'overlay-host'
+]);
+
+const REQUIRED_OVERLAY_KINDS = Object.freeze([
+  'tooltip',
+  'toast',
+  'popover',
+  'lightbox',
+  'menu',
+  'dialog'
+]);
+
+const REQUIRED_PORTAL_POLICIES = Object.freeze([
+  'stacked',
+  'modal',
+  'nonmodal',
+  'toast-region',
+  'clipping-escape'
+]);
+
+const REQUIRED_BOUNDARIES = Object.freeze([
+  'no-rmt-kernel-import-of-xtend-types',
+  'no-product-bound-surface-list',
+  'no-product-local-registry-repaint',
+  'portal-layer-policy-is-generic',
+  'resources-owned-per-surface-instance',
+  'normal-ui-no-html-string-renderer'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_MODULE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SUITE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_DOCS,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE_DOC,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_RUNTIME,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TYPES
+]);
+
+const REQUIRED_DOCS = Object.freeze([
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_DOCS,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE_DOC,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_BACKLOG,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_EPIC
+]);
+
+function createRmtSurfaceResourceGraphRuntimePlan(options = {}) {
+  return {
+    schema: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SCHEMA,
+    reportSchema: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA,
+    fixtureSchema: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE_SCHEMA,
+    actionEffectRuntimeSchema: RMT_ACTION_EFFECT_RUNTIME_SCHEMA,
+    actionEffectRuntimeWorkpackage: RMT_ACTION_EFFECT_RUNTIME_WORKPACKAGE,
+    eventRoutingRuntimeSchema: RMT_EVENT_ROUTING_RUNTIME_SCHEMA,
+    eventRoutingRuntimeWorkpackage: RMT_EVENT_ROUTING_RUNTIME_WORKPACKAGE,
+    workpackage: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE,
+    status: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TARGET,
+    module: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_MODULE,
+    runtime: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_RUNTIME,
+    types: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TYPES,
+    suite: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SUITE,
+    fixture: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE,
+    docs: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_DOCS,
+    workpackageDocument: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE_DOC,
+    localGate: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_LOCAL_GATE,
+    packageScript: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_PACKAGE_SCRIPT,
+    surfaceCapabilities: REQUIRED_SURFACE_CAPABILITIES.slice(),
+    surfaceKinds: REQUIRED_SURFACE_KINDS.slice(),
+    overlayKinds: REQUIRED_OVERLAY_KINDS.slice(),
+    portalPolicies: REQUIRED_PORTAL_POLICIES.slice(),
+    boundaries: REQUIRED_BOUNDARIES.slice(),
+    artifactPaths: REQUIRED_ARTIFACTS.slice(),
+    requiredDocs: REQUIRED_DOCS.slice(),
+    model: {
+      keyedSurfaceRepeater: true,
+      surfaceLifecycleGeneric: true,
+      portalLayerPolicyGeneric: true,
+      overlayStackSharedAcrossKinds: true,
+      minimizePreservesResources: true,
+      destroyReleasesResources: true,
+      destroyDetachesEventOwners: true,
+      persistenceAdapterInjected: true,
+      productSurfaceTaxonomyAllowed: false,
+      productRegistryRepaintRequired: false,
+      htmlStringRendererRequired: false
+    },
+    kernelBoundary: KERNEL_BOUNDARY,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    nextDecision: NEXT_DECISION
+  };
+}
+
+function validateRmtSurfaceResourceGraphRuntimePlan(plan = createRmtSurfaceResourceGraphRuntimePlan()) {
+  const errors = [];
+  const model = plan && plan.model ? plan.model : {};
+
+  if (!plan || plan.schema !== RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SCHEMA) errors.push(`schema must be ${RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SCHEMA}`);
+  if (!plan || plan.reportSchema !== RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA) errors.push(`reportSchema must be ${RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA}`);
+  if (!plan || plan.fixtureSchema !== RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE_SCHEMA) errors.push(`fixtureSchema must be ${RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE_SCHEMA}`);
+  if (!plan || plan.actionEffectRuntimeSchema !== RMT_ACTION_EFFECT_RUNTIME_SCHEMA) errors.push('WP-E18-10 must build on WP-E18-08 action effect runtime');
+  if (!plan || plan.actionEffectRuntimeWorkpackage !== RMT_ACTION_EFFECT_RUNTIME_WORKPACKAGE) errors.push('action effect runtime workpackage must be WP-E18-08');
+  if (!plan || plan.eventRoutingRuntimeSchema !== RMT_EVENT_ROUTING_RUNTIME_SCHEMA) errors.push('WP-E18-10 must build on WP-E18-09 event routing runtime');
+  if (!plan || plan.eventRoutingRuntimeWorkpackage !== RMT_EVENT_ROUTING_RUNTIME_WORKPACKAGE) errors.push('event routing runtime workpackage must be WP-E18-09');
+  if (!plan || plan.workpackage !== RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE) errors.push(`workpackage must be ${RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE}`);
+  if (!plan || plan.status !== RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_STATUS) errors.push(`status must be ${RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_STATUS}`);
+  if (!plan || plan.targetReadiness !== RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TARGET) errors.push(`targetReadiness must be ${RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TARGET}`);
+  REQUIRED_SURFACE_CAPABILITIES.forEach((capability) => {
+    if (!plan || !plan.surfaceCapabilities.includes(capability)) errors.push(`surface capability missing: ${capability}`);
+  });
+  REQUIRED_SURFACE_KINDS.forEach((kind) => {
+    if (!plan || !plan.surfaceKinds.includes(kind)) errors.push(`surface kind missing: ${kind}`);
+  });
+  REQUIRED_OVERLAY_KINDS.forEach((kind) => {
+    if (!plan || !plan.overlayKinds.includes(kind)) errors.push(`overlay kind missing: ${kind}`);
+  });
+  REQUIRED_PORTAL_POLICIES.forEach((policy) => {
+    if (!plan || !plan.portalPolicies.includes(policy)) errors.push(`portal policy missing: ${policy}`);
+  });
+  REQUIRED_BOUNDARIES.forEach((boundary) => {
+    if (!plan || !plan.boundaries.includes(boundary)) errors.push(`boundary missing: ${boundary}`);
+  });
+  REQUIRED_ARTIFACTS.forEach((artifact) => {
+    if (!plan || !plan.artifactPaths.includes(artifact)) errors.push(`artifact missing: ${artifact}`);
+  });
+  REQUIRED_DOCS.forEach((doc) => {
+    if (!plan || !plan.requiredDocs.includes(doc)) errors.push(`doc missing: ${doc}`);
+  });
+  if (model.keyedSurfaceRepeater !== true) errors.push('keyed surface repeater must be implemented');
+  if (model.surfaceLifecycleGeneric !== true) errors.push('surface lifecycle must be generic');
+  if (model.portalLayerPolicyGeneric !== true) errors.push('portal layer policy must be generic');
+  if (model.overlayStackSharedAcrossKinds !== true) errors.push('overlay stack must be shared across overlay kinds');
+  if (model.minimizePreservesResources !== true) errors.push('minimize must preserve resources');
+  if (model.destroyReleasesResources !== true) errors.push('destroy must release resources');
+  if (model.destroyDetachesEventOwners !== true) errors.push('destroy must detach event owners');
+  if (model.persistenceAdapterInjected !== true) errors.push('persistence adapter must be injected');
+  if (model.productSurfaceTaxonomyAllowed !== false) errors.push('product surface taxonomy must stay disallowed');
+  if (model.productRegistryRepaintRequired !== false) errors.push('product registry repaint must not be required');
+  if (model.htmlStringRendererRequired !== false) errors.push('html string renderer must not be required');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  if (!plan || plan.nextWorkpackage !== NEXT_WORKPACKAGE) errors.push(`nextWorkpackage must be ${NEXT_WORKPACKAGE}`);
+  if (!plan || plan.nextDecision !== NEXT_DECISION) errors.push(`nextDecision must be ${NEXT_DECISION}`);
+
+  return {
+    schema: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    workpackage: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE,
+    checkedAt: 'static-local'
+  };
+}
+
+function createRmtSurfaceResourceGraphRuntimeReport(options = {}) {
+  const plan = options.plan || createRmtSurfaceResourceGraphRuntimePlan(options);
+  const validation = validateRmtSurfaceResourceGraphRuntimePlan(plan);
+
+  return {
+    schema: RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors.slice(),
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    surfaceCapabilityCount: plan.surfaceCapabilities.length,
+    surfaceKindCount: plan.surfaceKinds.length,
+    overlayKindCount: plan.overlayKinds.length,
+    portalPolicyCount: plan.portalPolicies.length,
+    boundaryCount: plan.boundaries.length,
+    productSurfaceTaxonomyAllowed: plan.model.productSurfaceTaxonomyAllowed,
+    productRegistryRepaintRequired: plan.model.productRegistryRepaintRequired,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision,
+    kernelBoundary: plan.kernelBoundary
+  };
+}
+
+module.exports = {
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  REQUIRED_ARTIFACTS,
+  REQUIRED_BOUNDARIES,
+  REQUIRED_DOCS,
+  REQUIRED_OVERLAY_KINDS,
+  REQUIRED_PORTAL_POLICIES,
+  REQUIRED_SURFACE_CAPABILITIES,
+  REQUIRED_SURFACE_KINDS,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_BACKLOG,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_DOCS,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_EPIC,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_FIXTURE_SCHEMA,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_LOCAL_GATE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_MODULE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_PACKAGE_SCRIPT,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_REPORT_SCHEMA,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_RUNTIME,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SCHEMA,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_STATUS,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_SUITE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TARGET,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_TYPES,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE,
+  RMT_SURFACE_RESOURCE_GRAPH_RUNTIME_WORKPACKAGE_DOC,
+  createRmtSurfaceResourceGraphRuntimePlan,
+  createRmtSurfaceResourceGraphRuntimeReport,
+  validateRmtSurfaceResourceGraphRuntimePlan
+};

package/catalog/surface-manager-controller.js

@@ -83,7 +83,11 @@ const REQUIRED_SURFACE_TYPES = Object.freeze([
   'dialog',
   'drawer',
   'popover',
-  'tooltip'
+  'tooltip',
+  'region',
+  'toast',
+  'lightbox',
+  'menu'
 ]);
 
 const REQUIRED_DIAGNOSTIC_CODES = Object.freeze([

package/catalog/surface-manager-materialization.js

@@ -39,10 +39,16 @@ const SURFACE_MATERIALIZATION_DIAGNOSTICS = Object.freeze([
 const MATERIALIZED_COMPONENT_TAGS = Object.freeze([
   'x-surface-manager',
   'x-surface-window',
+  'x-surface-region',
   'x-side-panel',
   'x-modal',
   'x-dialog',
-  'x-drawer'
+  'x-drawer',
+  'x-popover',
+  'x-tooltip',
+  'x-toast',
+  'x-lightbox',
+  'x-menu'
 ]);
 
 const RUNTIME_ARTIFACTS = Object.freeze([

package/catalog/surface-manager-overlay-bridge.js

@@ -30,7 +30,12 @@ const RUNTIME_ARTIFACTS = Object.freeze([
   'components/xsurfacemanager-controller.js',
   'components/xmodal.js',
   'components/xdialog.js',
-  'components/xdrawer.js'
+  'components/xdrawer.js',
+  'components/xpopover.js',
+  'components/xtooltip.js',
+  'components/xtoast.js',
+  'components/xlightbox.js',
+  'components/xmenu.js'
 ]);
 
 const REQUIRED_ARTIFACTS = Object.freeze([
@@ -57,13 +62,23 @@ const COMPONENT_TAGS = Object.freeze([
   'x-surface-manager',
   'x-modal',
   'x-dialog',
-  'x-drawer'
+  'x-drawer',
+  'x-popover',
+  'x-tooltip',
+  'x-toast',
+  'x-lightbox',
+  'x-menu'
 ]);
 
 const OVERLAY_SURFACE_TYPES = Object.freeze([
   'modal',
   'dialog',
-  'drawer'
+  'drawer',
+  'popover',
+  'tooltip',
+  'toast',
+  'lightbox',
+  'menu'
 ]);
 
 const LEGACY_EVENTS = Object.freeze([
@@ -73,7 +88,18 @@ const LEGACY_EVENTS = Object.freeze([
   'dialog-closed',
   'drawer-opened',
   'drawer-closed',
-  'drawer-route-selected'
+  'drawer-route-selected',
+  'popover-opened',
+  'popover-closed',
+  'tooltip-opened',
+  'tooltip-closed',
+  'toast-shown',
+  'toast-dismissed',
+  'lightbox-opened',
+  'lightbox-closed',
+  'menu-opened',
+  'menu-closed',
+  'menu-navigate'
 ]);
 
 const BRIDGE_EVENTS = Object.freeze([
@@ -84,7 +110,12 @@ const BRIDGE_EVENTS = Object.freeze([
 const LEGACY_STATE_KEYS = Object.freeze([
   'modal-open-<id>',
   'dialog-open-<id>',
-  'xdrawer-open-<id>'
+  'xdrawer-open-<id>',
+  'xpopover-open-<id>',
+  'xtooltip-open-<id>',
+  'xtoast-state-<id>',
+  'xlightbox-open-<id>',
+  'xmenu-state-<id>'
 ]);
 
 function includesAll(values, required) {
@@ -122,7 +153,7 @@ function createSurfaceManagerOverlayBridgePlan(options = {}) {
     legacyStateKeys: LEGACY_STATE_KEYS.slice(),
     runtimeModel: {
       bridge: 'xsurfaceoverlay-bridge-adapts-existing-overlays-to-surface-records',
-      managerIntegration: 'x-surface-manager-overlays-slot-auto-registers-x-modal-x-dialog-x-drawer',
+      managerIntegration: 'x-surface-manager-overlays-slot-auto-registers-compatible-overlay-primitives',
       commandBridge: 'surface-overlay-command-to-controller-operation',
       lifecycleBridge: 'legacy-overlay-events-to-surface-controller',
       stackPolicy: 'single-controller-stack-for-windows-panels-and-compatible-overlays',
@@ -135,6 +166,8 @@ function createSurfaceManagerOverlayBridgePlan(options = {}) {
       legacyLifecycleEventsPreserved: true,
       legacyStateKeysPreserved: true,
       modalDialogDrawerProfilesImplemented: true,
+      lightweightOverlayProfilesImplemented: true,
+      normalizedOverlayCommandsImplemented: true,
       controllerReusedFromWpSm02: true,
       createsSecondRegistry: false,
       externalNetworkAllowedInLocalGate: false,
@@ -170,6 +203,8 @@ function validateSurfaceManagerOverlayBridgePlan(plan = createSurfaceManagerOver
   if (!plan || plan.featureFlags.surfaceOverlayCommandImplemented !== true) errors.push('surface-overlay-command must be implemented');
   if (!plan || plan.featureFlags.legacyLifecycleEventsPreserved !== true) errors.push('legacy overlay events must be preserved');
   if (!plan || plan.featureFlags.legacyStateKeysPreserved !== true) errors.push('legacy overlay state keys must be preserved');
+  if (!plan || plan.featureFlags.lightweightOverlayProfilesImplemented !== true) errors.push('lightweight overlay profiles must be implemented');
+  if (!plan || plan.featureFlags.normalizedOverlayCommandsImplemented !== true) errors.push('overlay command normalization must be implemented');
   if (!plan || plan.featureFlags.controllerReusedFromWpSm02 !== true) errors.push('WP-SM-06 must reuse WP-SM-02 controller');
   if (!plan || plan.featureFlags.createsSecondRegistry !== false) errors.push('WP-SM-06 must not create a second registry');
   if (!plan || plan.featureFlags.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel boundary must stay clean');

package/catalog/surface-manager-workbench-fixture.js

@@ -19,9 +19,9 @@ const SURFACE_MANAGER_WORKBENCH_CONTRACT = 'development/XTend-SurfaceManager-RMT
 const SURFACE_MANAGER_WORKBENCH_WORKPACKAGE_DOC = 'development/WP-SM-05-RMT-first-Workbench-Fixture-bauen.md';
 const SURFACE_MANAGER_WORKBENCH_DOCS = 'docs/surface-manager-workbench-fixture.md';
 const SURFACE_MANAGER_WORKBENCH_FIXTURE = 'xtendrmt/surface-workbench.rmt';
-const SURFACE_MANAGER_WORKBENCH_HOST = 'xtendrmt-surface-workbench.html';
 const SURFACE_MANAGER_WORKBENCH_RUNTIME = 'xtendrmt/surface-workbench.js';
 const SURFACE_MANAGER_WORKBENCH_BROWSER_SMOKE = 'tests/browser/fixtures/rmt-surface-workbench-smoke.html';
+const SURFACE_MANAGER_WORKBENCH_HOST = SURFACE_MANAGER_WORKBENCH_BROWSER_SMOKE;
 const SURFACE_MANAGER_WORKBENCH_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-workbench-fixture --json';
 const SURFACE_MANAGER_WORKBENCH_PACKAGE_SCRIPT = 'npm run test:surface-workbench-fixture';
 const NEXT_WORKPACKAGE = 'WP-SM-06';

package/catalog/surface-type-capability-matrix.d.ts

@@ -0,0 +1,61 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogOptions,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+export interface SurfaceTypeCapabilityLowering {
+  type: string;
+  kind: string;
+  component: string;
+  managerSlot: string;
+  portalPolicy: string;
+}
+
+export interface SurfaceTypeCapabilityRow {
+  schema?: string;
+  kind: string;
+  runtimeType: string;
+  componentTag: string;
+  managerSlot: string;
+  layer: string;
+  stackPolicy: string;
+  layoutEligible: boolean;
+  resourceOwnership: string;
+  portalPolicy: string;
+  rmtSyntax?: string;
+  lowersTo?: SurfaceTypeCapabilityLowering;
+  kernelBoundary?: string;
+}
+
+export interface SurfaceTypeCapabilityMatrix {
+  schema: string;
+  reportSchema: string;
+  generatedAt: string;
+  rowCount: number;
+  runtimeTypes: readonly string[];
+  regionKinds: readonly string[];
+  overlayKinds: readonly string[];
+  rows: readonly SurfaceTypeCapabilityRow[];
+  policies: {
+    additiveCompatibility: boolean;
+    controllerIsSingleRegistry: boolean;
+    rmtKernelImportsXtendTypes: boolean;
+    genericUiComponent: string;
+    portalPolicyComponent: string;
+  };
+  kernelBoundary: string;
+}
+
+export declare const KERNEL_BOUNDARY: XtendCatalogConstant;
+export declare const OVERLAY_KINDS: readonly string[];
+export declare const REGION_KINDS: readonly string[];
+export declare const SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA: string;
+export declare const SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA: string;
+export declare const SURFACE_TYPE_CAPABILITY_ROWS: readonly SurfaceTypeCapabilityRow[];
+export declare function createSurfaceTypeCapabilityMatrix(options?: XtendCatalogOptions): SurfaceTypeCapabilityMatrix;
+export declare function listSurfaceTypeCapabilityRows(): readonly SurfaceTypeCapabilityRow[];
+export declare function resolveSurfaceTypeCapability(kind: string): SurfaceTypeCapabilityRow | null;
+export declare function surfaceKindToComponentTag(kind: string, fallback?: string): string;
+export declare function surfaceKindToRuntimeType(kind: string, fallback?: string): string;
+export declare function validateSurfaceTypeCapabilityMatrix(matrix?: SurfaceTypeCapabilityMatrix): XtendCatalogReport;

package/catalog/surface-type-capability-matrix.js

@@ -0,0 +1,183 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA = 'xtend.surface.type-capability-matrix.v1';
+const SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA = 'xtend.surface.type-capability-matrix-report.v1';
+
+const REGION_KINDS = Object.freeze(['root', 'workspace', 'page', 'card', 'list', 'region', 'overlay-host']);
+const OVERLAY_KINDS = Object.freeze(['modal', 'dialog', 'drawer', 'popover', 'tooltip', 'toast', 'lightbox', 'menu']);
+
+const SURFACE_TYPE_CAPABILITY_ROWS = Object.freeze([
+  Object.freeze({
+    kind: 'window',
+    runtimeType: 'window',
+    componentTag: 'x-surface-window',
+    managerSlot: 'windows',
+    layer: 'workspace',
+    stackPolicy: 'focus-stack',
+    layoutEligible: true,
+    resourceOwnership: 'surface-instance',
+    portalPolicy: 'stacked'
+  }),
+  Object.freeze({
+    kind: 'panel',
+    runtimeType: 'side-panel',
+    componentTag: 'x-side-panel',
+    managerSlot: 'panels',
+    layer: 'panel',
+    stackPolicy: 'docked-or-overlay-panel',
+    layoutEligible: true,
+    resourceOwnership: 'surface-instance',
+    portalPolicy: 'nonmodal'
+  }),
+  Object.freeze({
+    kind: 'side-panel',
+    runtimeType: 'side-panel',
+    componentTag: 'x-side-panel',
+    managerSlot: 'panels',
+    layer: 'panel',
+    stackPolicy: 'docked-or-overlay-panel',
+    layoutEligible: true,
+    resourceOwnership: 'surface-instance',
+    portalPolicy: 'nonmodal'
+  }),
+  ...REGION_KINDS.map((kind) => Object.freeze({
+    kind,
+    runtimeType: 'region',
+    componentTag: 'x-surface-region',
+    managerSlot: 'default',
+    layer: kind === 'overlay-host' ? 'overlay-host' : 'workspace',
+    stackPolicy: kind === 'overlay-host' ? 'portal-host' : 'managed-region',
+    layoutEligible: ['workspace', 'page', 'card', 'list', 'region'].includes(kind),
+    resourceOwnership: 'surface-instance',
+    portalPolicy: kind === 'overlay-host' ? 'clipping-escape' : 'stacked'
+  })),
+  ...OVERLAY_KINDS.map((kind) => Object.freeze({
+    kind,
+    runtimeType: kind,
+    componentTag: `x-${kind}`,
+    managerSlot: 'overlays',
+    layer: kind === 'toast' ? 'toast-region' : (kind === 'drawer' ? 'panel-overlay' : 'overlay'),
+    stackPolicy: kind === 'toast' ? 'toast-region' : (kind === 'modal' || kind === 'dialog' || kind === 'lightbox' ? 'modal' : 'nonmodal'),
+    layoutEligible: false,
+    resourceOwnership: 'overlay-instance',
+    portalPolicy: kind === 'toast' ? 'toast-region' : (kind === 'popover' || kind === 'tooltip' || kind === 'menu' ? 'clipping-escape' : 'modal')
+  }))
+]);
+
+const SURFACE_TYPE_CAPABILITY_INDEX = Object.freeze(Object.fromEntries(
+  SURFACE_TYPE_CAPABILITY_ROWS.map((row) => [row.kind, row])
+));
+
+function withSyntax(row) {
+  return Object.freeze({
+    schema: SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA,
+    ...row,
+    rmtSyntax: `surface <id> kind ${row.kind} component ${row.componentTag}`,
+    lowersTo: {
+      type: row.runtimeType,
+      kind: row.kind,
+      component: row.componentTag,
+      managerSlot: row.managerSlot,
+      portalPolicy: row.portalPolicy
+    },
+    kernelBoundary: KERNEL_BOUNDARY
+  });
+}
+
+function listSurfaceTypeCapabilityRows() {
+  return SURFACE_TYPE_CAPABILITY_ROWS.map(withSyntax);
+}
+
+function resolveSurfaceTypeCapability(kind) {
+  const key = String(kind || '').trim().toLowerCase();
+  const row = SURFACE_TYPE_CAPABILITY_INDEX[key] || null;
+  return row ? withSyntax(row) : null;
+}
+
+function surfaceKindToRuntimeType(kind, fallback = 'window') {
+  const row = resolveSurfaceTypeCapability(kind);
+  return row ? row.runtimeType : fallback;
+}
+
+function surfaceKindToComponentTag(kind, fallback = 'x-surface-window') {
+  const row = resolveSurfaceTypeCapability(kind);
+  return row ? row.componentTag : fallback;
+}
+
+function createSurfaceTypeCapabilityMatrix(options = {}) {
+  const rows = listSurfaceTypeCapabilityRows();
+  return {
+    schema: SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA,
+    reportSchema: SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA,
+    generatedAt: options.generatedAt || 'static-local',
+    rowCount: rows.length,
+    runtimeTypes: Array.from(new Set(rows.map((row) => row.runtimeType))),
+    regionKinds: REGION_KINDS.slice(),
+    overlayKinds: OVERLAY_KINDS.slice(),
+    rows,
+    policies: {
+      additiveCompatibility: true,
+      controllerIsSingleRegistry: true,
+      rmtKernelImportsXtendTypes: false,
+      genericUiComponent: 'x-surface-region',
+      portalPolicyComponent: 'x-surface-portal'
+    },
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function validateSurfaceTypeCapabilityMatrix(matrix = createSurfaceTypeCapabilityMatrix()) {
+  const errors = [];
+  const rows = Array.isArray(matrix && matrix.rows) ? matrix.rows : [];
+  const byKind = new Map(rows.map((row) => [row.kind, row]));
+
+  if (!matrix || matrix.schema !== SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA) errors.push(`schema must be ${SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA}`);
+  if (!matrix || matrix.reportSchema !== SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA}`);
+  ['window', 'panel', 'side-panel', ...REGION_KINDS, ...OVERLAY_KINDS].forEach((kind) => {
+    if (!byKind.has(kind)) errors.push(`surface kind missing: ${kind}`);
+  });
+  REGION_KINDS.forEach((kind) => {
+    const row = byKind.get(kind);
+    if (!row || row.runtimeType !== 'region') errors.push(`${kind} must lower to region`);
+    if (!row || row.componentTag !== 'x-surface-region') errors.push(`${kind} must materialize as x-surface-region`);
+  });
+  OVERLAY_KINDS.forEach((kind) => {
+    const row = byKind.get(kind);
+    if (!row || row.runtimeType !== kind) errors.push(`${kind} must keep a matching runtime type`);
+    if (!row || row.managerSlot !== 'overlays') errors.push(`${kind} must use overlays slot`);
+  });
+  rows.forEach((row) => {
+    if (!row.rmtSyntax || !row.rmtSyntax.includes(`kind ${row.kind}`) || !row.rmtSyntax.includes(`component ${row.componentTag}`)) {
+      errors.push(`${row.kind} must expose modern RMT syntax mapping`);
+    }
+    if (row.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`${row.kind} must keep kernel boundary`);
+  });
+  if (!matrix || matrix.policies.controllerIsSingleRegistry !== true) errors.push('SurfaceController must remain the single registry');
+  if (!matrix || matrix.policies.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel must not import XTend types');
+  if (!matrix || matrix.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+
+  return {
+    schema: SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    rowCount: rows.length
+  };
+}
+
+module.exports = {
+  KERNEL_BOUNDARY,
+  OVERLAY_KINDS,
+  REGION_KINDS,
+  SURFACE_TYPE_CAPABILITY_MATRIX_REPORT_SCHEMA,
+  SURFACE_TYPE_CAPABILITY_MATRIX_SCHEMA,
+  SURFACE_TYPE_CAPABILITY_ROWS,
+  createSurfaceTypeCapabilityMatrix,
+  listSurfaceTypeCapabilityRows,
+  resolveSurfaceTypeCapability,
+  surfaceKindToComponentTag,
+  surfaceKindToRuntimeType,
+  validateSurfaceTypeCapabilityMatrix
+};