@ccslabs/xtend 0.1.0-rc.1

package/catalog/surface-manager-layout-engines.js

@@ -0,0 +1,161 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_MANAGER_LAYOUT_ENGINE_SCHEMA = 'xtend.surface.layout-engine.v1';
+const SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA = 'xtend.surface.layout-engine-report.v1';
+const SURFACE_MANAGER_LAYOUT_ENGINE_DIAGNOSTIC_SCHEMA = 'xtend.surface.layout-engine-diagnostic.v1';
+const SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE = 'WP-SM-16';
+const SURFACE_MANAGER_LAYOUT_ENGINE_STATUS = 'implemented-docking-split-tile-layout-engines';
+const SURFACE_MANAGER_LAYOUT_ENGINE_TARGET = 'surface-layout-engines-ready';
+const SURFACE_MANAGER_LAYOUT_ENGINE_MODULE = 'catalog/surface-manager-layout-engines.js';
+const SURFACE_MANAGER_LAYOUT_ENGINE_SUITE = 'tests/components/surface_manager_layout_engines_suite.js';
+const SURFACE_MANAGER_LAYOUT_ENGINE_FIXTURE = 'tests/components/fixtures/xsurfacemanager-layout-engines.component.html';
+const SURFACE_MANAGER_LAYOUT_ENGINE_BACKLOG = 'development/BACKLOG-XTend-SurfaceManager-App-Shell-und-RMT-Surface-Runtime.md';
+const SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE_DOC = 'development/WP-SM-16-Docking-Split-Panes-Tiling-und-Layout-Engines-ergaenzen.md';
+const SURFACE_MANAGER_LAYOUT_ENGINE_DOCS = 'docs/surface-manager-layout-engines.md';
+const SURFACE_MANAGER_LAYOUT_ENGINE_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-layout-engines --json';
+const SURFACE_MANAGER_LAYOUT_ENGINE_PACKAGE_SCRIPT = 'npm run test:surface-layout-engines';
+
+const LAYOUT_ENGINES = Object.freeze(['freeform', 'docked', 'split', 'tile', 'stacked']);
+const MANAGER_METHODS = Object.freeze([
+  'snapshotSurfaceLayout',
+  'applyLayoutEngine',
+  'dockSurface',
+  'undockSurface'
+]);
+const LAYOUT_ENGINE_EVENTS = Object.freeze([
+  'surface-layout-engine-applied',
+  'surface-layout-changed'
+]);
+const REQUIRED_ARTIFACTS = Object.freeze([
+  SURFACE_MANAGER_LAYOUT_ENGINE_MODULE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_SUITE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_FIXTURE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_BACKLOG,
+  SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_LAYOUT_ENGINE_DOCS,
+  'components/xsurfacemanager.js',
+  'components/xsurfacemanager.d.ts',
+  'components/xsurfacewindow.js',
+  'components/xsidepanel.js',
+  'components/xsidepanel.d.ts'
+]);
+
+function includesAll(values, required) {
+  return required.every((entry) => Array.isArray(values) && values.includes(entry));
+}
+
+function createSurfaceManagerLayoutEnginesPlan(options = {}) {
+  return {
+    schema: SURFACE_MANAGER_LAYOUT_ENGINE_SCHEMA,
+    reportSchema: SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA,
+    diagnosticSchema: SURFACE_MANAGER_LAYOUT_ENGINE_DIAGNOSTIC_SCHEMA,
+    workpackage: SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE,
+    status: SURFACE_MANAGER_LAYOUT_ENGINE_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: SURFACE_MANAGER_LAYOUT_ENGINE_TARGET,
+    module: SURFACE_MANAGER_LAYOUT_ENGINE_MODULE,
+    suite: SURFACE_MANAGER_LAYOUT_ENGINE_SUITE,
+    fixture: SURFACE_MANAGER_LAYOUT_ENGINE_FIXTURE,
+    backlog: SURFACE_MANAGER_LAYOUT_ENGINE_BACKLOG,
+    workpackageDocument: SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE_DOC,
+    docs: SURFACE_MANAGER_LAYOUT_ENGINE_DOCS,
+    localGate: SURFACE_MANAGER_LAYOUT_ENGINE_LOCAL_GATE,
+    packageScript: SURFACE_MANAGER_LAYOUT_ENGINE_PACKAGE_SCRIPT,
+    requiredArtifacts: REQUIRED_ARTIFACTS.slice(),
+    layoutEngines: LAYOUT_ENGINES.slice(),
+    managerMethods: MANAGER_METHODS.slice(),
+    events: LAYOUT_ENGINE_EVENTS.slice(),
+    runtimeBoundary: {
+      managerOwnsLayoutPolicy: true,
+      controllerOwnsRegistry: true,
+      snapshotCompatibleBounds: true,
+      visibleDockingRuntime: true,
+      splitPaneRuntime: true,
+      tileRuntime: true,
+      stackedResponsiveFallback: true,
+      viewportConstrainedBounds: true,
+      collisionSnapRules: true,
+      sidePanelFloatingMode: true,
+      createsSecondRegistry: false,
+      rmtKernelImportsXtendTypes: false,
+      networkRequired: false
+    },
+    nextWorkpackage: 'WP-SM-17',
+    nextDecision: 'remote-surface-trust-policy',
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function validateSurfaceManagerLayoutEnginesPlan(plan = createSurfaceManagerLayoutEnginesPlan()) {
+  const errors = [];
+  if (!plan || plan.schema !== SURFACE_MANAGER_LAYOUT_ENGINE_SCHEMA) errors.push(`schema must be ${SURFACE_MANAGER_LAYOUT_ENGINE_SCHEMA}`);
+  if (!plan || plan.reportSchema !== SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA}`);
+  if (!plan || plan.diagnosticSchema !== SURFACE_MANAGER_LAYOUT_ENGINE_DIAGNOSTIC_SCHEMA) errors.push(`diagnosticSchema must be ${SURFACE_MANAGER_LAYOUT_ENGINE_DIAGNOSTIC_SCHEMA}`);
+  if (!plan || plan.workpackage !== SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE) errors.push(`workpackage must be ${SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE}`);
+  if (!plan || plan.status !== SURFACE_MANAGER_LAYOUT_ENGINE_STATUS) errors.push(`status must be ${SURFACE_MANAGER_LAYOUT_ENGINE_STATUS}`);
+  if (!includesAll(plan && plan.layoutEngines, LAYOUT_ENGINES)) errors.push('layout engines missing');
+  if (!includesAll(plan && plan.managerMethods, MANAGER_METHODS)) errors.push('layout manager methods missing');
+  if (!includesAll(plan && plan.events, LAYOUT_ENGINE_EVENTS)) errors.push('layout engine events missing');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.managerOwnsLayoutPolicy !== true) errors.push('manager must own layout policy');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.controllerOwnsRegistry !== true) errors.push('controller must own registry');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.visibleDockingRuntime !== true) errors.push('docking must be visible runtime behavior');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.snapshotCompatibleBounds !== true) errors.push('layout bounds must be snapshot compatible');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.createsSecondRegistry !== false) errors.push('layout engine must not create a second registry');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  return {
+    schema: SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    workpackage: SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE,
+    targetReadiness: SURFACE_MANAGER_LAYOUT_ENGINE_TARGET
+  };
+}
+
+function createSurfaceManagerLayoutEnginesReport(options = {}) {
+  const plan = options.plan || createSurfaceManagerLayoutEnginesPlan(options);
+  const validation = validateSurfaceManagerLayoutEnginesPlan(plan);
+  return {
+    schema: SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    layoutEngines: plan.layoutEngines.slice(),
+    managerMethods: plan.managerMethods.length,
+    events: plan.events.length,
+    localGate: plan.localGate,
+    packageScript: plan.packageScript,
+    kernelBoundary: plan.kernelBoundary,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision
+  };
+}
+
+module.exports = {
+  KERNEL_BOUNDARY,
+  LAYOUT_ENGINES,
+  LAYOUT_ENGINE_EVENTS,
+  MANAGER_METHODS,
+  REQUIRED_ARTIFACTS,
+  SURFACE_MANAGER_LAYOUT_ENGINE_BACKLOG,
+  SURFACE_MANAGER_LAYOUT_ENGINE_DIAGNOSTIC_SCHEMA,
+  SURFACE_MANAGER_LAYOUT_ENGINE_DOCS,
+  SURFACE_MANAGER_LAYOUT_ENGINE_FIXTURE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_LOCAL_GATE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_MODULE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_PACKAGE_SCRIPT,
+  SURFACE_MANAGER_LAYOUT_ENGINE_REPORT_SCHEMA,
+  SURFACE_MANAGER_LAYOUT_ENGINE_SCHEMA,
+  SURFACE_MANAGER_LAYOUT_ENGINE_STATUS,
+  SURFACE_MANAGER_LAYOUT_ENGINE_SUITE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_TARGET,
+  SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE,
+  SURFACE_MANAGER_LAYOUT_ENGINE_WORKPACKAGE_DOC,
+  createSurfaceManagerLayoutEnginesPlan,
+  createSurfaceManagerLayoutEnginesReport,
+  validateSurfaceManagerLayoutEnginesPlan
+};

package/catalog/surface-manager-lazy-loading.d.ts

@@ -0,0 +1,35 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const KERNEL_BOUNDARY: XtendCatalogConstant;
+export declare const MANAGER_METHODS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SKELETON_LOADER_CONTRACT: string;
+export declare const STYLE_REGISTRY_CONTRACT: string;
+export declare const SURFACE_LOADING_EVENTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_LOADING_POLICIES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_LOADING_POLICY_SCHEMA: string;
+export declare const SURFACE_LOADING_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_BACKLOG: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_LAZY_LOADING_FIXTURE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_LAZY_LOADING_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_MODULE: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_SCHEMA: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_STATUS: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_SUITE: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_TARGET: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare function createSurfaceManagerLazyLoadingPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerLazyLoadingReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerLazyLoadingPlan(plan?: unknown): XtendCatalogReport;

package/catalog/surface-manager-lazy-loading.js

@@ -0,0 +1,173 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_MANAGER_LAZY_LOADING_SCHEMA = 'xtend.surface.lazy-loading.v1';
+const SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA = 'xtend.surface.lazy-loading-report.v1';
+const SURFACE_LOADING_POLICY_SCHEMA = 'xtend.surface.loading-policy.v1';
+const SURFACE_LOADING_REPORT_SCHEMA = 'xtend.surface.loading-report.v1';
+const SKELETON_LOADER_CONTRACT = 'xtend.loader.skeleton-loader.v1';
+const STYLE_REGISTRY_CONTRACT = 'xtend.loader.style-registry.v1';
+const SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE = 'WP-SM-13';
+const SURFACE_MANAGER_LAZY_LOADING_STATUS = 'implemented-shell-first-lazy-surface-loading';
+const SURFACE_MANAGER_LAZY_LOADING_TARGET = 'shell-first-surface-skeleton-hydration-ready';
+const SURFACE_MANAGER_LAZY_LOADING_MODULE = 'catalog/surface-manager-lazy-loading.js';
+const SURFACE_MANAGER_LAZY_LOADING_SUITE = 'tests/components/surface_manager_lazy_hydration_suite.js';
+const SURFACE_MANAGER_LAZY_LOADING_FIXTURE = 'tests/components/fixtures/xsurfacemanager-lazy-hydration.component.html';
+const SURFACE_MANAGER_LAZY_LOADING_BACKLOG = 'development/BACKLOG-XTend-SurfaceManager-App-Shell-und-RMT-Surface-Runtime.md';
+const SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE_DOC = 'development/WP-SM-13-Shell-first-Lazy-Surface-Loading-mit-Skeleton-Hydration-bauen.md';
+const SURFACE_MANAGER_LAZY_LOADING_DOCS = 'docs/surface-manager-lazy-hydration.md';
+const SURFACE_MANAGER_LAZY_LOADING_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-lazy-hydration --json';
+const SURFACE_MANAGER_LAZY_LOADING_PACKAGE_SCRIPT = 'npm run test:surface-lazy-hydration';
+
+const SURFACE_LOADING_POLICIES = Object.freeze(['eager', 'visible', 'open', 'idle', 'route']);
+const MANAGER_METHODS = Object.freeze([
+  'snapshotSurfaceLoading',
+  'hydrateSurfaceContent'
+]);
+const SURFACE_LOADING_EVENTS = Object.freeze([
+  'surface-content-loading',
+  'surface-content-hydrated',
+  'surface-content-hydration-skipped',
+  'surface-content-hydration-error'
+]);
+const REQUIRED_ARTIFACTS = Object.freeze([
+  SURFACE_MANAGER_LAZY_LOADING_MODULE,
+  SURFACE_MANAGER_LAZY_LOADING_SUITE,
+  SURFACE_MANAGER_LAZY_LOADING_FIXTURE,
+  SURFACE_MANAGER_LAZY_LOADING_BACKLOG,
+  SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_LAZY_LOADING_DOCS,
+  'components/xsurfacemanager.js',
+  'components/xsurfacemanager.d.ts',
+  'xtend-loader.js',
+  'xtendrmt/rmt-core.esm.js',
+  'xtendrmt/rmt-runtime.esm.js',
+  'xtendrmt/rmt-runtime.browser.js'
+]);
+
+function includesAll(values, required) {
+  return required.every((entry) => Array.isArray(values) && values.includes(entry));
+}
+
+function createSurfaceManagerLazyLoadingPlan(options = {}) {
+  return {
+    schema: SURFACE_MANAGER_LAZY_LOADING_SCHEMA,
+    reportSchema: SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA,
+    loadingPolicySchema: SURFACE_LOADING_POLICY_SCHEMA,
+    loadingReportSchema: SURFACE_LOADING_REPORT_SCHEMA,
+    skeletonLoaderContract: SKELETON_LOADER_CONTRACT,
+    styleRegistryContract: STYLE_REGISTRY_CONTRACT,
+    workpackage: SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE,
+    status: SURFACE_MANAGER_LAZY_LOADING_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: SURFACE_MANAGER_LAZY_LOADING_TARGET,
+    module: SURFACE_MANAGER_LAZY_LOADING_MODULE,
+    suite: SURFACE_MANAGER_LAZY_LOADING_SUITE,
+    fixture: SURFACE_MANAGER_LAZY_LOADING_FIXTURE,
+    backlog: SURFACE_MANAGER_LAZY_LOADING_BACKLOG,
+    workpackageDocument: SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE_DOC,
+    docs: SURFACE_MANAGER_LAZY_LOADING_DOCS,
+    localGate: SURFACE_MANAGER_LAZY_LOADING_LOCAL_GATE,
+    packageScript: SURFACE_MANAGER_LAZY_LOADING_PACKAGE_SCRIPT,
+    requiredArtifacts: REQUIRED_ARTIFACTS.slice(),
+    policies: SURFACE_LOADING_POLICIES.slice(),
+    managerMethods: MANAGER_METHODS.slice(),
+    events: SURFACE_LOADING_EVENTS.slice(),
+    runtimeBoundary: {
+      shellFirst: true,
+      usesXTendLoader: true,
+      usesSkeletonLoader: true,
+      usesStyleRegistry: true,
+      protectsUnstyledContent: true,
+      keepsSkeletonOnHydrationFailure: true,
+      supportsParsedownContainerSkeleton: true,
+      supportsRemoteCapableContentSlots: true,
+      createsSecondRegistry: false,
+      rmtKernelImportsXtendTypes: false,
+      docsAppMonkeypatch: false,
+      networkRequired: false
+    },
+    nextWorkpackage: 'WP-SM-14',
+    nextDecision: 'xrouter-bound-surface-lifecycles',
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function validateSurfaceManagerLazyLoadingPlan(plan = createSurfaceManagerLazyLoadingPlan()) {
+  const errors = [];
+  if (!plan || plan.schema !== SURFACE_MANAGER_LAZY_LOADING_SCHEMA) errors.push(`schema must be ${SURFACE_MANAGER_LAZY_LOADING_SCHEMA}`);
+  if (!plan || plan.reportSchema !== SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA}`);
+  if (!plan || plan.loadingPolicySchema !== SURFACE_LOADING_POLICY_SCHEMA) errors.push(`loadingPolicySchema must be ${SURFACE_LOADING_POLICY_SCHEMA}`);
+  if (!plan || plan.skeletonLoaderContract !== SKELETON_LOADER_CONTRACT) errors.push(`skeletonLoaderContract must be ${SKELETON_LOADER_CONTRACT}`);
+  if (!plan || plan.styleRegistryContract !== STYLE_REGISTRY_CONTRACT) errors.push(`styleRegistryContract must be ${STYLE_REGISTRY_CONTRACT}`);
+  if (!plan || plan.workpackage !== SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE) errors.push(`workpackage must be ${SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE}`);
+  if (!plan || plan.status !== SURFACE_MANAGER_LAZY_LOADING_STATUS) errors.push(`status must be ${SURFACE_MANAGER_LAZY_LOADING_STATUS}`);
+  if (!includesAll(plan && plan.policies, SURFACE_LOADING_POLICIES)) errors.push('surface loading policies missing');
+  if (!includesAll(plan && plan.managerMethods, MANAGER_METHODS)) errors.push('surface loading manager methods missing');
+  if (!includesAll(plan && plan.events, SURFACE_LOADING_EVENTS)) errors.push('surface loading events missing');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.shellFirst !== true) errors.push('shell-first boundary must be true');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.usesXTendLoader !== true) errors.push('lazy hydration must use XTendLoader');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.usesSkeletonLoader !== true) errors.push('lazy hydration must use SkeletonLoader');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.protectsUnstyledContent !== true) errors.push('unstyled content protection must be true');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.createsSecondRegistry !== false) errors.push('lazy hydration must not create a second registry');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.docsAppMonkeypatch !== false) errors.push('docs app monkeypatch must stay false');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  return {
+    schema: SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    workpackage: SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE,
+    targetReadiness: SURFACE_MANAGER_LAZY_LOADING_TARGET
+  };
+}
+
+function createSurfaceManagerLazyLoadingReport(options = {}) {
+  const plan = options.plan || createSurfaceManagerLazyLoadingPlan(options);
+  const validation = validateSurfaceManagerLazyLoadingPlan(plan);
+  return {
+    schema: SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    policies: plan.policies.slice(),
+    managerMethods: plan.managerMethods.length,
+    events: plan.events.length,
+    localGate: plan.localGate,
+    packageScript: plan.packageScript,
+    kernelBoundary: plan.kernelBoundary,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision
+  };
+}
+
+module.exports = {
+  KERNEL_BOUNDARY,
+  MANAGER_METHODS,
+  REQUIRED_ARTIFACTS,
+  SKELETON_LOADER_CONTRACT,
+  STYLE_REGISTRY_CONTRACT,
+  SURFACE_LOADING_EVENTS,
+  SURFACE_LOADING_POLICIES,
+  SURFACE_LOADING_POLICY_SCHEMA,
+  SURFACE_LOADING_REPORT_SCHEMA,
+  SURFACE_MANAGER_LAZY_LOADING_BACKLOG,
+  SURFACE_MANAGER_LAZY_LOADING_DOCS,
+  SURFACE_MANAGER_LAZY_LOADING_FIXTURE,
+  SURFACE_MANAGER_LAZY_LOADING_LOCAL_GATE,
+  SURFACE_MANAGER_LAZY_LOADING_MODULE,
+  SURFACE_MANAGER_LAZY_LOADING_PACKAGE_SCRIPT,
+  SURFACE_MANAGER_LAZY_LOADING_REPORT_SCHEMA,
+  SURFACE_MANAGER_LAZY_LOADING_SCHEMA,
+  SURFACE_MANAGER_LAZY_LOADING_STATUS,
+  SURFACE_MANAGER_LAZY_LOADING_SUITE,
+  SURFACE_MANAGER_LAZY_LOADING_TARGET,
+  SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE,
+  SURFACE_MANAGER_LAZY_LOADING_WORKPACKAGE_DOC,
+  createSurfaceManagerLazyLoadingPlan,
+  createSurfaceManagerLazyLoadingReport,
+  validateSurfaceManagerLazyLoadingPlan
+};

package/catalog/surface-manager-materialization.d.ts

@@ -0,0 +1,37 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const KERNEL_BOUNDARY: XtendCatalogConstant;
+export declare const MATERIALIZED_COMPONENT_TAGS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const RUNTIME_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_ID: XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_SCHEMA: string;
+export declare const SURFACE_CONTROLLER_SCHEMA: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_BACKLOG: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_FIXTURE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_MATERIALIZATION_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_MODULE: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_SCHEMA: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_STATUS: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_SUITE: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_TARGET: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_SCHEMA: string;
+export declare const SURFACE_MATERIALIZATION_DIAGNOSTICS: XtendCatalogConstant;
+export declare const SURFACE_MATERIALIZATION_OPERATIONS: XtendCatalogConstant;
+export declare const SURFACE_MATERIALIZATION_SCHEMA: string;
+export declare const SURFACE_RECORD_SCHEMA: string;
+export declare function createSurfaceManagerMaterializationPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerMaterializationReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerMaterializationPlan(plan?: unknown): XtendCatalogReport;

package/catalog/surface-manager-materialization.js

@@ -0,0 +1,202 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_MANAGER_MATERIALIZATION_SCHEMA = 'xtend.surface.native-materialization.v1';
+const SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA = 'xtend.surface.native-materialization-report.v1';
+const SURFACE_MATERIALIZATION_SCHEMA = 'xtend.surface.materialization.v1';
+const SURFACE_ADAPTER_SCHEMA = 'xtend.surface.adapter.v1';
+const SURFACE_ADAPTER_ID = 'xtend.surface';
+const SURFACE_MANAGER_SCHEMA = 'xtend.surface.manager.v1';
+const SURFACE_RECORD_SCHEMA = 'xtend.surface.record.v1';
+const SURFACE_CONTROLLER_SCHEMA = 'xtend.surface.controller.v1';
+const SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE = 'WP-SM-11';
+const SURFACE_MANAGER_MATERIALIZATION_STATUS = 'implemented-native-surface-materialization';
+const SURFACE_MANAGER_MATERIALIZATION_TARGET = 'native-surfaces-template-materialization-ready';
+const SURFACE_MANAGER_MATERIALIZATION_MODULE = 'catalog/surface-manager-materialization.js';
+const SURFACE_MANAGER_MATERIALIZATION_SUITE = 'tests/rmt/surface_manager_materialization_suite.js';
+const SURFACE_MANAGER_MATERIALIZATION_FIXTURE = 'tests/fixtures/rmt-surface-materialization-shell.rmt';
+const SURFACE_MANAGER_MATERIALIZATION_BACKLOG = 'development/BACKLOG-XTend-SurfaceManager-App-Shell-und-RMT-Surface-Runtime.md';
+const SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE_DOC = 'development/WP-SM-11-Native-surfaces-in-XTend-UI-Komponenten-materialisieren.md';
+const SURFACE_MANAGER_MATERIALIZATION_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-native-materialization --json';
+const SURFACE_MANAGER_MATERIALIZATION_PACKAGE_SCRIPT = 'npm run test:surface-native-materialization';
+
+const SURFACE_MATERIALIZATION_OPERATIONS = Object.freeze([
+  'mapSurfaces',
+  'materializeSurfaces',
+  'registerSurface',
+  'snapshotSurfaces'
+]);
+
+const SURFACE_MATERIALIZATION_DIAGNOSTICS = Object.freeze([
+  'rmt.surface.missing_id',
+  'rmt.surface.missing_manager',
+  'rmt.surface.missing_component',
+  'rmt.surface.materialization.target.missing',
+  'rmt.surface.target.unsupported'
+]);
+
+const MATERIALIZED_COMPONENT_TAGS = Object.freeze([
+  'x-surface-manager',
+  'x-surface-window',
+  'x-side-panel',
+  'x-modal',
+  'x-dialog',
+  'x-drawer'
+]);
+
+const RUNTIME_ARTIFACTS = Object.freeze([
+  'xtendrmt/rmt-core.esm.js',
+  'xtendrmt/rmt-runtime.esm.js',
+  'xtendrmt/rmt-runtime.browser.js',
+  'xtendrmt/rmt-core.d.ts'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  SURFACE_MANAGER_MATERIALIZATION_MODULE,
+  SURFACE_MANAGER_MATERIALIZATION_SUITE,
+  SURFACE_MANAGER_MATERIALIZATION_FIXTURE,
+  SURFACE_MANAGER_MATERIALIZATION_BACKLOG,
+  SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE_DOC,
+  ...RUNTIME_ARTIFACTS
+]);
+
+function includesAll(values, required) {
+  return required.every((entry) => Array.isArray(values) && values.includes(entry));
+}
+
+function createSurfaceManagerMaterializationPlan(options = {}) {
+  return {
+    schema: SURFACE_MANAGER_MATERIALIZATION_SCHEMA,
+    reportSchema: SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA,
+    materializationSchema: SURFACE_MATERIALIZATION_SCHEMA,
+    adapterSchema: SURFACE_ADAPTER_SCHEMA,
+    adapterId: SURFACE_ADAPTER_ID,
+    surfaceManagerSchema: SURFACE_MANAGER_SCHEMA,
+    surfaceRecordSchema: SURFACE_RECORD_SCHEMA,
+    surfaceControllerSchema: SURFACE_CONTROLLER_SCHEMA,
+    workpackage: SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE,
+    status: SURFACE_MANAGER_MATERIALIZATION_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: SURFACE_MANAGER_MATERIALIZATION_TARGET,
+    module: SURFACE_MANAGER_MATERIALIZATION_MODULE,
+    suite: SURFACE_MANAGER_MATERIALIZATION_SUITE,
+    fixture: SURFACE_MANAGER_MATERIALIZATION_FIXTURE,
+    backlog: SURFACE_MANAGER_MATERIALIZATION_BACKLOG,
+    workpackageDocument: SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE_DOC,
+    localGate: SURFACE_MANAGER_MATERIALIZATION_LOCAL_GATE,
+    packageScript: SURFACE_MANAGER_MATERIALIZATION_PACKAGE_SCRIPT,
+    runtimeFactory: 'createRmtSurfaceAdapter',
+    operations: SURFACE_MATERIALIZATION_OPERATIONS.slice(),
+    diagnostics: SURFACE_MATERIALIZATION_DIAGNOSTICS.slice(),
+    materializedComponentTags: MATERIALIZED_COMPONENT_TAGS.slice(),
+    runtimeArtifacts: RUNTIME_ARTIFACTS.slice(),
+    requiredArtifacts: REQUIRED_ARTIFACTS.slice(),
+    consumes: [
+      'surfaces[*].manager',
+      'surfaces[*].component',
+      'surfaces[*].route',
+      'surfaces[*].schedule',
+      'surfaces[*].bounds',
+      'surfaces[*].placement',
+      'surfaces[*].mode',
+      'components[*] as content and manager bindings'
+    ],
+    runtimeBoundary: {
+      materializesDom: true,
+      generatesSurfaceComponentsFromNativeRecords: true,
+      keepsComponentRecordsAsContentBindings: true,
+      createsSecondRegistry: false,
+      replacesFabric: false,
+      replacesRmtKernel: false,
+      monkeypatchesDocsApp: false,
+      kernelVisible: false,
+      rmtKernelImportsXtendTypes: false
+    },
+    nextWorkpackage: 'WP-SM-12',
+    nextDecision: 'shell-layout-and-surface-zone-policy',
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function validateSurfaceManagerMaterializationPlan(plan = createSurfaceManagerMaterializationPlan()) {
+  const errors = [];
+
+  if (!plan || plan.schema !== SURFACE_MANAGER_MATERIALIZATION_SCHEMA) errors.push(`schema must be ${SURFACE_MANAGER_MATERIALIZATION_SCHEMA}`);
+  if (!plan || plan.reportSchema !== SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA}`);
+  if (!plan || plan.materializationSchema !== SURFACE_MATERIALIZATION_SCHEMA) errors.push(`materializationSchema must be ${SURFACE_MATERIALIZATION_SCHEMA}`);
+  if (!plan || plan.adapterSchema !== SURFACE_ADAPTER_SCHEMA) errors.push(`adapterSchema must be ${SURFACE_ADAPTER_SCHEMA}`);
+  if (!plan || plan.adapterId !== SURFACE_ADAPTER_ID) errors.push(`adapterId must be ${SURFACE_ADAPTER_ID}`);
+  if (!plan || plan.workpackage !== SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE) errors.push(`workpackage must be ${SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE}`);
+  if (!plan || plan.status !== SURFACE_MANAGER_MATERIALIZATION_STATUS) errors.push(`status must be ${SURFACE_MANAGER_MATERIALIZATION_STATUS}`);
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.materializesDom !== true) errors.push('WP-SM-11 must own native surface DOM materialization');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.generatesSurfaceComponentsFromNativeRecords !== true) errors.push('native surfaces must generate XTend UI surface components');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.keepsComponentRecordsAsContentBindings !== true) errors.push('component records must remain content bindings');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.createsSecondRegistry !== false) errors.push('materialization must not create a second surface registry');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.monkeypatchesDocsApp !== false) errors.push('materialization must stay framework-native, not docs-app-specific');
+  if (!includesAll(plan && plan.operations, SURFACE_MATERIALIZATION_OPERATIONS)) errors.push('materialization operations missing');
+  if (!includesAll(plan && plan.materializedComponentTags, MATERIALIZED_COMPONENT_TAGS)) errors.push('materialized component tags missing');
+  if (!includesAll(plan && plan.runtimeArtifacts, RUNTIME_ARTIFACTS)) errors.push('runtime artifacts missing');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+
+  return {
+    schema: SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    workpackage: SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE,
+    targetReadiness: SURFACE_MANAGER_MATERIALIZATION_TARGET
+  };
+}
+
+function createSurfaceManagerMaterializationReport(options = {}) {
+  const plan = options.plan || createSurfaceManagerMaterializationPlan(options);
+  const validation = validateSurfaceManagerMaterializationPlan(plan);
+
+  return {
+    schema: SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    adapterId: plan.adapterId,
+    operationCount: plan.operations.length,
+    materializedComponentTags: plan.materializedComponentTags.slice(),
+    localGate: plan.localGate,
+    packageScript: plan.packageScript,
+    kernelBoundary: plan.kernelBoundary,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision
+  };
+}
+
+module.exports = {
+  KERNEL_BOUNDARY,
+  MATERIALIZED_COMPONENT_TAGS,
+  REQUIRED_ARTIFACTS,
+  RUNTIME_ARTIFACTS,
+  SURFACE_ADAPTER_ID,
+  SURFACE_ADAPTER_SCHEMA,
+  SURFACE_CONTROLLER_SCHEMA,
+  SURFACE_MANAGER_MATERIALIZATION_BACKLOG,
+  SURFACE_MANAGER_MATERIALIZATION_FIXTURE,
+  SURFACE_MANAGER_MATERIALIZATION_LOCAL_GATE,
+  SURFACE_MANAGER_MATERIALIZATION_MODULE,
+  SURFACE_MANAGER_MATERIALIZATION_PACKAGE_SCRIPT,
+  SURFACE_MANAGER_MATERIALIZATION_REPORT_SCHEMA,
+  SURFACE_MANAGER_MATERIALIZATION_SCHEMA,
+  SURFACE_MANAGER_MATERIALIZATION_STATUS,
+  SURFACE_MANAGER_MATERIALIZATION_SUITE,
+  SURFACE_MANAGER_MATERIALIZATION_TARGET,
+  SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE,
+  SURFACE_MANAGER_MATERIALIZATION_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_SCHEMA,
+  SURFACE_MATERIALIZATION_DIAGNOSTICS,
+  SURFACE_MATERIALIZATION_OPERATIONS,
+  SURFACE_MATERIALIZATION_SCHEMA,
+  SURFACE_RECORD_SCHEMA,
+  createSurfaceManagerMaterializationPlan,
+  createSurfaceManagerMaterializationReport,
+  validateSurfaceManagerMaterializationPlan
+};

package/catalog/surface-manager-native-rmt-surfaces.d.ts

@@ -0,0 +1,48 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const KERNEL_BOUNDARY: XtendCatalogConstant;
+export declare const NEXT_DECISION: XtendCatalogConstant;
+export declare const NEXT_WORKPACKAGE: string;
+export declare const REQUIRED_ADAPTERS: XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_DOMAINS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_ID: XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_KIND: XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_OPERATIONS: XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_SCHEMA: string;
+export declare const SURFACE_CONTROLLER_SCHEMA: string;
+export declare const SURFACE_DOMAIN: XtendCatalogConstant;
+export declare const SURFACE_FIELDS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_NATIVE_RMT_CONTRACT: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_NATIVE_RMT_FIXTURE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_NATIVE_RMT_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_MODULE: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_PLAN: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_NATIVE_RMT_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_SCHEMA: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_STATUS: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_SUITE: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_TARGET: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_NATIVE_RMT_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_SCHEMA: string;
+export declare const SURFACE_QUALITY_GATES_SCHEMA: string;
+export declare const SURFACE_RECORD_SCHEMA: string;
+export declare const SURFACE_REFERENCE_CHECKS: XtendCatalogConstant;
+export declare const SURFACE_SNAPSHOT_SCHEMA: string;
+export declare const SURFACE_TYPES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const TOOLING_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare function createSurfaceManagerNativeRmtSurfacesPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerNativeRmtSurfacesReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerNativeRmtSurfacesPlan(plan?: unknown): XtendCatalogReport;