@ccslabs/xtend 0.1.0-rc.1

package/catalog/surface-manager-runtime-release-handoff.js

@@ -0,0 +1,245 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SCHEMA = 'xtend.surface.runtime-release-handoff.v1';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA = 'xtend.surface.runtime-release-handoff-report.v1';
+const SURFACE_MANAGER_RUNTIME_MIGRATION_NOTES_SCHEMA = 'xtend.surface.runtime-migration-notes.v1';
+const SURFACE_MANAGER_RUNTIME_RELEASE_GATE_MATRIX_SCHEMA = 'xtend.surface.runtime-release-gate-matrix.v1';
+const SURFACE_MANAGER_RUNTIME_COMPATIBILITY_NOTES_SCHEMA = 'xtend.surface.runtime-compatibility-notes.v1';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE = 'WP-SM-19';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_STATUS = 'accepted-productive-surface-runtime-handoff';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_TARGET = 'productive-surface-runtime-release-ready';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_MODULE = 'catalog/surface-manager-runtime-release-handoff.js';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SUITE = 'tests/rmt/surface_manager_runtime_release_handoff_suite.js';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_BACKLOG = 'development/BACKLOG-XTend-SurfaceManager-App-Shell-und-RMT-Surface-Runtime.md';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_CONTRACT = 'development/XTend-SurfaceManager-Runtime-Release-Handoff-Contract.md';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE_DOC = 'development/WP-SM-19-Migration-Doku-und-Release-Handoff-fuer-Surface-Runtime-finalisieren.md';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_DOCS = 'docs/surface-manager-runtime-release-handoff.md';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-runtime-release-handoff --json';
+const SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_PACKAGE_SCRIPT = 'npm run test:surface-runtime-release-handoff';
+
+const PRODUCTIVE_RUNTIME_CLAIMS = Object.freeze([
+  'productive-xtend-surface-adapter-runtime',
+  'native-surfaces-materialize-xtend-ui-components',
+  'restore-key-snapshot-hydration',
+  'shell-first-skeleton-hydration',
+  'xrouter-bound-surface-lifecycle',
+  'modal-focus-inert-stack-policy',
+  'layout-engines-docking-split-tile-stacked',
+  'remote-surface-trust-policy',
+  'browser-lab-visual-stability'
+]);
+
+const RELEASE_GATES = Object.freeze([
+  'rmt-surface-authoring',
+  'surface-controller',
+  'surface-manager',
+  'surface-side-panel',
+  'surface-workbench-fixture',
+  'surface-overlay-bridge',
+  'surface-manager-quality',
+  'surface-native-rmt',
+  'surface-release-handoff',
+  'surface-adapter-runtime',
+  'surface-native-materialization',
+  'surface-persistence',
+  'surface-lazy-hydration',
+  'surface-route-lifecycle',
+  'surface-stack-policy',
+  'surface-layout-engines',
+  'surface-remote-policy',
+  'surface-browser-lab',
+  'surface-runtime-release-handoff'
+]);
+
+const UPDATED_GUIDES = Object.freeze([
+  'docs/surface-manager-authoring-guide.md',
+  'docs/surface-manager-migration-guide.md',
+  'docs/surface-manager-release-handoff.md',
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_DOCS
+]);
+
+const COMPATIBILITY_FIXTURES = Object.freeze([
+  'tests/fixtures/rmt-surface-manager-component-lab.rmt',
+  'tests/fixtures/rmt-surface-native-domain.rmt',
+  'tests/fixtures/rmt-surface-materialization-shell.rmt',
+  'tests/browser/fixtures/rmt-surface-workbench-smoke.html',
+  'tests/browser/fixtures/surface-manager-browser-lab.html',
+  'tests/components/fixtures/xsurfacemanager-persistence.component.html',
+  'tests/components/fixtures/xsurfacemanager-lazy-hydration.component.html',
+  'tests/components/fixtures/xsurfacemanager-route-lifecycle.component.html',
+  'tests/components/fixtures/xsurfacemanager-stack-policy.component.html',
+  'tests/components/fixtures/xsurfacemanager-layout-engines.component.html',
+  'tests/components/fixtures/xsurfacemanager-remote-policy.component.html'
+]);
+
+const OPEN_SCOPES = Object.freeze([
+  'project-specific-pixel-artifact-storage',
+  'release-owner-signoff-before-public-npm-publish',
+  'optional-command-palette-and-workspace-surface-types',
+  'remote-runtime-loading-remains-out-of-scope',
+  'docs-app-php-parsedown-host-boundary-remains'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_MODULE,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SUITE,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_BACKLOG,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_CONTRACT,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_DOCS,
+  ...UPDATED_GUIDES,
+  ...COMPATIBILITY_FIXTURES,
+  'package.json',
+  'scripts/run_xtend_tests.js'
+]);
+
+function includesAll(values, required) {
+  return required.every((entry) => Array.isArray(values) && values.includes(entry));
+}
+
+function createSurfaceManagerRuntimeReleaseHandoffPlan(options = {}) {
+  return {
+    schema: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SCHEMA,
+    reportSchema: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA,
+    migrationNotesSchema: SURFACE_MANAGER_RUNTIME_MIGRATION_NOTES_SCHEMA,
+    releaseGateMatrixSchema: SURFACE_MANAGER_RUNTIME_RELEASE_GATE_MATRIX_SCHEMA,
+    compatibilityNotesSchema: SURFACE_MANAGER_RUNTIME_COMPATIBILITY_NOTES_SCHEMA,
+    workpackage: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE,
+    status: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_TARGET,
+    module: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_MODULE,
+    suite: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SUITE,
+    backlog: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_BACKLOG,
+    contract: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_CONTRACT,
+    workpackageDocument: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE_DOC,
+    docs: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_DOCS,
+    localGate: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_LOCAL_GATE,
+    packageScript: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_PACKAGE_SCRIPT,
+    requiredArtifacts: REQUIRED_ARTIFACTS.slice(),
+    updatedGuides: UPDATED_GUIDES.slice(),
+    compatibilityFixtures: COMPATIBILITY_FIXTURES.slice(),
+    productiveRuntimeClaims: PRODUCTIVE_RUNTIME_CLAIMS.slice(),
+    releaseGates: RELEASE_GATES.slice(),
+    openScopes: OPEN_SCOPES.slice(),
+    releaseDecision: {
+      productiveRuntimeClaimDocumented: true,
+      nativeSurfacesAuthoringDefault: true,
+      componentMetadataCompatibilityKept: true,
+      adapterRuntimeImplemented: true,
+      materializationImplemented: true,
+      browserLabGateRequired: true,
+      semverClassification: '0.x-minor-with-migration-notes',
+      publicPublishBlockedUntilReleaseOwnerSignoff: true
+    },
+    runtimeBoundary: {
+      surfaceControllerSingleRegistry: true,
+      surfaceManagerSupportsXtendUi: true,
+      replacesFabric: false,
+      replacesRmtKernel: false,
+      replacesXState: false,
+      docsAppMonkeypatch: false,
+      remoteRuntimeExecutionInKernel: false,
+      createsSecondRegistry: false,
+      externalNetworkAllowedInLocalGate: false,
+      rmtKernelImportsXtendTypes: false
+    },
+    nextWorkpackage: 'surface-runtime-maintenance',
+    nextDecision: 'release-owner-signoff-or-project-specific-hardening',
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function validateSurfaceManagerRuntimeReleaseHandoffPlan(plan = createSurfaceManagerRuntimeReleaseHandoffPlan()) {
+  const errors = [];
+
+  if (!plan || plan.schema !== SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SCHEMA) errors.push(`schema must be ${SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SCHEMA}`);
+  if (!plan || plan.reportSchema !== SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA}`);
+  if (!plan || plan.migrationNotesSchema !== SURFACE_MANAGER_RUNTIME_MIGRATION_NOTES_SCHEMA) errors.push(`migrationNotesSchema must be ${SURFACE_MANAGER_RUNTIME_MIGRATION_NOTES_SCHEMA}`);
+  if (!plan || plan.releaseGateMatrixSchema !== SURFACE_MANAGER_RUNTIME_RELEASE_GATE_MATRIX_SCHEMA) errors.push(`releaseGateMatrixSchema must be ${SURFACE_MANAGER_RUNTIME_RELEASE_GATE_MATRIX_SCHEMA}`);
+  if (!plan || plan.compatibilityNotesSchema !== SURFACE_MANAGER_RUNTIME_COMPATIBILITY_NOTES_SCHEMA) errors.push(`compatibilityNotesSchema must be ${SURFACE_MANAGER_RUNTIME_COMPATIBILITY_NOTES_SCHEMA}`);
+  if (!plan || plan.workpackage !== SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE) errors.push(`workpackage must be ${SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE}`);
+  if (!plan || plan.status !== SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_STATUS) errors.push(`status must be ${SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_STATUS}`);
+  if (!plan || plan.targetReadiness !== SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_TARGET) errors.push(`targetReadiness must be ${SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_TARGET}`);
+  if (!includesAll(plan && plan.productiveRuntimeClaims, PRODUCTIVE_RUNTIME_CLAIMS)) errors.push('productive runtime claims missing');
+  if (!includesAll(plan && plan.releaseGates, RELEASE_GATES)) errors.push('release gates missing');
+  if (!includesAll(plan && plan.updatedGuides, UPDATED_GUIDES)) errors.push('updated guides missing');
+  if (!includesAll(plan && plan.compatibilityFixtures, COMPATIBILITY_FIXTURES)) errors.push('compatibility fixtures missing');
+  if (!includesAll(plan && plan.openScopes, OPEN_SCOPES)) errors.push('open scopes missing');
+  if (!plan || !plan.releaseDecision || plan.releaseDecision.productiveRuntimeClaimDocumented !== true) errors.push('productive runtime claim must be documented');
+  if (!plan || !plan.releaseDecision || plan.releaseDecision.nativeSurfacesAuthoringDefault !== true) errors.push('native surfaces must be the authoring default');
+  if (!plan || !plan.releaseDecision || plan.releaseDecision.componentMetadataCompatibilityKept !== true) errors.push('component metadata compatibility must be kept');
+  if (!plan || !plan.releaseDecision || plan.releaseDecision.adapterRuntimeImplemented !== true) errors.push('adapter runtime must be implemented');
+  if (!plan || !plan.releaseDecision || plan.releaseDecision.materializationImplemented !== true) errors.push('materialization must be implemented');
+  if (!plan || !plan.releaseDecision || plan.releaseDecision.publicPublishBlockedUntilReleaseOwnerSignoff !== true) errors.push('public publish boundary must be explicit');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.surfaceControllerSingleRegistry !== true) errors.push('SurfaceController must remain the single registry');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.replacesFabric !== false) errors.push('SurfaceManager must not replace Fabric');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.replacesRmtKernel !== false) errors.push('SurfaceManager must not replace RMT kernel');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.replacesXState !== false) errors.push('SurfaceManager must not replace xstate');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.createsSecondRegistry !== false) errors.push('runtime handoff must not create a second registry');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel boundary must stay clean');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+
+  return {
+    schema: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    workpackage: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE,
+    targetReadiness: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_TARGET
+  };
+}
+
+function createSurfaceManagerRuntimeReleaseHandoffReport(options = {}) {
+  const plan = options.plan || createSurfaceManagerRuntimeReleaseHandoffPlan(options);
+  const validation = validateSurfaceManagerRuntimeReleaseHandoffPlan(plan);
+
+  return {
+    schema: SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    localGate: plan.localGate,
+    packageScript: plan.packageScript,
+    productiveRuntimeClaims: plan.productiveRuntimeClaims.length,
+    releaseGates: plan.releaseGates.length,
+    openScopes: plan.openScopes.slice(),
+    semverClassification: plan.releaseDecision.semverClassification,
+    kernelBoundary: plan.kernelBoundary,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision
+  };
+}
+
+module.exports = {
+  COMPATIBILITY_FIXTURES,
+  KERNEL_BOUNDARY,
+  OPEN_SCOPES,
+  PRODUCTIVE_RUNTIME_CLAIMS,
+  RELEASE_GATES,
+  REQUIRED_ARTIFACTS,
+  SURFACE_MANAGER_RUNTIME_COMPATIBILITY_NOTES_SCHEMA,
+  SURFACE_MANAGER_RUNTIME_MIGRATION_NOTES_SCHEMA,
+  SURFACE_MANAGER_RUNTIME_RELEASE_GATE_MATRIX_SCHEMA,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_BACKLOG,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_CONTRACT,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_DOCS,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_LOCAL_GATE,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_MODULE,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_PACKAGE_SCRIPT,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_REPORT_SCHEMA,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SCHEMA,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_STATUS,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_SUITE,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_TARGET,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE,
+  SURFACE_MANAGER_RUNTIME_RELEASE_HANDOFF_WORKPACKAGE_DOC,
+  UPDATED_GUIDES,
+  createSurfaceManagerRuntimeReleaseHandoffPlan,
+  createSurfaceManagerRuntimeReleaseHandoffReport,
+  validateSurfaceManagerRuntimeReleaseHandoffPlan
+};

package/catalog/surface-manager-side-panel-runtime.d.ts

@@ -0,0 +1,46 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const COMPONENT_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const COMPONENT_FIXTURES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const COMPONENT_SUITES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const COMPONENT_TAGS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const KERNEL_BOUNDARY: XtendCatalogConstant;
+export declare const NEXT_DECISION: XtendCatalogConstant;
+export declare const NEXT_WORKPACKAGE: string;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_EVENTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_MANAGER_METHODS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_MODES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_PANEL_METHODS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_PLACEMENTS: XtendCatalogConstant;
+export declare const RUNTIME_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SOURCE_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_CONTROLLER_SCHEMA: string;
+export declare const SURFACE_MANAGER_SCHEMA: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_CONTRACT: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_SIDE_PANEL_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_MODULE: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_PLAN: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_SCHEMA: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_STATUS: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_SUITE: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_TARGET: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const SURFACE_RECORD_SCHEMA: string;
+export declare const SURFACE_SNAPSHOT_SCHEMA: string;
+export declare function createSurfaceManagerSidePanelPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerSidePanelReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerSidePanelPlan(plan?: unknown): XtendCatalogReport;

package/catalog/surface-manager-side-panel-runtime.js

@@ -0,0 +1,307 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_MANAGER_SIDE_PANEL_SCHEMA = 'xtend.surface.side-panel-runtime.v1';
+const SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA = 'xtend.surface.side-panel-runtime-report.v1';
+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_SNAPSHOT_SCHEMA = 'xtend.surface.snapshot.v1';
+const SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE = 'WP-SM-04';
+const SURFACE_MANAGER_SIDE_PANEL_STATUS = 'accepted-side-panel-runtime';
+const SURFACE_MANAGER_SIDE_PANEL_TARGET = 'responsive-side-panel-surface-runtime-ready';
+const SURFACE_MANAGER_SIDE_PANEL_MODULE = 'catalog/surface-manager-side-panel-runtime.js';
+const SURFACE_MANAGER_SIDE_PANEL_SUITE = 'tests/components/surface_manager_side_panel_suite.js';
+const SURFACE_MANAGER_SIDE_PANEL_PLAN = 'development/XTend-SurfaceManager-und-Multi-Window-Plan.md';
+const SURFACE_MANAGER_SIDE_PANEL_CONTRACT = 'development/XTend-SurfaceManager-SidePanel-Runtime-Contract.md';
+const SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE_DOC = 'development/WP-SM-04-x-side-panel-und-responsive-surface-modes-umsetzen.md';
+const SURFACE_MANAGER_SIDE_PANEL_DOCS = 'docs/surface-manager-side-panel-runtime.md';
+const SURFACE_MANAGER_SIDE_PANEL_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-side-panel --json';
+const SURFACE_MANAGER_SIDE_PANEL_PACKAGE_SCRIPT = 'npm run test:surface-side-panel';
+const NEXT_WORKPACKAGE = 'WP-SM-05';
+const NEXT_DECISION = 'rmt-first-workbench-fixture';
+
+const RUNTIME_ARTIFACTS = Object.freeze([
+  'components/xsurfacemanager.js',
+  'components/xsidepanel.js',
+  'components/xsidepanel.d.ts',
+  'components/xsurfacemanager-controller.js'
+]);
+
+const SOURCE_ARTIFACTS = Object.freeze([
+  'src/components/x-surface-manager/x-surface-manager.ts',
+  'src/components/x-side-panel/x-side-panel.ts'
+]);
+
+const COMPONENT_DOCS = Object.freeze([
+  'docs/components/xsidepanel.md'
+]);
+
+const COMPONENT_FIXTURES = Object.freeze([
+  'tests/components/fixtures/xsidepanel.component.html'
+]);
+
+const COMPONENT_SUITES = Object.freeze([
+  'tests/components/xsidepanel.component_suite.js'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  SURFACE_MANAGER_SIDE_PANEL_MODULE,
+  SURFACE_MANAGER_SIDE_PANEL_SUITE,
+  SURFACE_MANAGER_SIDE_PANEL_CONTRACT,
+  SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_SIDE_PANEL_DOCS,
+  ...RUNTIME_ARTIFACTS,
+  ...SOURCE_ARTIFACTS,
+  ...COMPONENT_DOCS,
+  ...COMPONENT_FIXTURES,
+  ...COMPONENT_SUITES
+]);
+
+const REQUIRED_DOCS = Object.freeze([
+  SURFACE_MANAGER_SIDE_PANEL_PLAN,
+  SURFACE_MANAGER_SIDE_PANEL_CONTRACT,
+  SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_SIDE_PANEL_DOCS,
+  'development/XTend-SurfaceManager-Window-Runtime-Contract.md',
+  'docs/surface-manager-window-runtime.md',
+  ...COMPONENT_DOCS
+]);
+
+const COMPONENT_TAGS = Object.freeze([
+  'x-surface-manager',
+  'x-side-panel'
+]);
+
+const REQUIRED_MANAGER_METHODS = Object.freeze([
+  'registerSurface',
+  'openSurface',
+  'closeSurface',
+  'focusSurface',
+  'updateSurface',
+  'resizeSurface',
+  'pinSurface',
+  'collapseSurface',
+  'expandSurface',
+  'dockSurface',
+  'restoreSurface',
+  'snapshot'
+]);
+
+const REQUIRED_PANEL_METHODS = Object.freeze([
+  'toSurfaceRecord',
+  'applySurfaceSnapshot',
+  'openPanel',
+  'closePanel',
+  'focusPanel',
+  'pinPanel',
+  'collapsePanel',
+  'expandPanel',
+  'setPanelMode',
+  'resizePanel',
+  'restorePanel'
+]);
+
+const REQUIRED_EVENTS = Object.freeze([
+  'surface-manager-ready',
+  'surface-registered',
+  'surface-opened',
+  'surface-closed',
+  'surface-focused',
+  'surface-updated',
+  'surface-layout-changed',
+  'surface-panel-command'
+]);
+
+const REQUIRED_PLACEMENTS = Object.freeze([
+  'left',
+  'right',
+  'bottom',
+  'inline'
+]);
+
+const REQUIRED_MODES = Object.freeze([
+  'docked',
+  'overlay',
+  'pinned',
+  'collapsed',
+  'fullscreen'
+]);
+
+function includesAll(values, required) {
+  return required.every((entry) => Array.isArray(values) && values.includes(entry));
+}
+
+function createSurfaceManagerSidePanelPlan(options = {}) {
+  return {
+    schema: SURFACE_MANAGER_SIDE_PANEL_SCHEMA,
+    reportSchema: SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA,
+    surfaceManagerSchema: SURFACE_MANAGER_SCHEMA,
+    surfaceRecordSchema: SURFACE_RECORD_SCHEMA,
+    surfaceControllerSchema: SURFACE_CONTROLLER_SCHEMA,
+    snapshotSchema: SURFACE_SNAPSHOT_SCHEMA,
+    workpackage: SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE,
+    status: SURFACE_MANAGER_SIDE_PANEL_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: SURFACE_MANAGER_SIDE_PANEL_TARGET,
+    module: SURFACE_MANAGER_SIDE_PANEL_MODULE,
+    suite: SURFACE_MANAGER_SIDE_PANEL_SUITE,
+    planningDocument: SURFACE_MANAGER_SIDE_PANEL_PLAN,
+    contract: SURFACE_MANAGER_SIDE_PANEL_CONTRACT,
+    workpackageDocument: SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE_DOC,
+    docs: SURFACE_MANAGER_SIDE_PANEL_DOCS,
+    localGate: SURFACE_MANAGER_SIDE_PANEL_LOCAL_GATE,
+    packageScript: SURFACE_MANAGER_SIDE_PANEL_PACKAGE_SCRIPT,
+    runtimeArtifacts: RUNTIME_ARTIFACTS.slice(),
+    sourceArtifacts: SOURCE_ARTIFACTS.slice(),
+    componentDocs: COMPONENT_DOCS.slice(),
+    componentFixtures: COMPONENT_FIXTURES.slice(),
+    componentSuites: COMPONENT_SUITES.slice(),
+    artifactPaths: REQUIRED_ARTIFACTS.slice(),
+    requiredDocs: REQUIRED_DOCS.slice(),
+    componentTags: COMPONENT_TAGS.slice(),
+    managerMethods: REQUIRED_MANAGER_METHODS.slice(),
+    panelMethods: REQUIRED_PANEL_METHODS.slice(),
+    events: REQUIRED_EVENTS.slice(),
+    placements: REQUIRED_PLACEMENTS.slice(),
+    modes: REQUIRED_MODES.slice(),
+    runtimeModel: {
+      manager: 'x-surface-manager owns controller-and-panel-slot',
+      panel: 'x-side-panel visible-managed-side-panel-surface',
+      controller: 'reuses-WP-SM-02-controller',
+      registration: 'slotchange-and-panel-connected-registration',
+      commandBridge: 'surface-panel-command-to-controller-update-and-resize',
+      snapshotBridge: 'controller-snapshot-to-panel-attributes-css-vars',
+      responsivePolicy: 'fullscreen-under-720-and-bottom-sheet-compatible',
+      manifestPolicy: 'manifest-loadable-components'
+    },
+    featureFlags: {
+      xSurfaceManagerImplemented: true,
+      xSurfaceWindowImplemented: true,
+      xSidePanelImplemented: true,
+      dockedModeImplemented: true,
+      overlayModeImplemented: true,
+      pinnedModeImplemented: true,
+      collapsedModeImplemented: true,
+      responsiveFullscreenImplemented: true,
+      nativeSurfacesDomainImplemented: false,
+      externalNetworkAllowedInLocalGate: false,
+      browserRequiredInLocalGate: false,
+      usesControllerFromWpSm02: true,
+      createsSecondRegistry: false,
+      rmtKernelImportsXtendTypes: false
+    },
+    kernelBoundary: KERNEL_BOUNDARY,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    nextDecision: NEXT_DECISION
+  };
+}
+
+function validateSurfaceManagerSidePanelPlan(plan = createSurfaceManagerSidePanelPlan()) {
+  const errors = [];
+
+  if (!plan || plan.schema !== SURFACE_MANAGER_SIDE_PANEL_SCHEMA) errors.push(`schema must be ${SURFACE_MANAGER_SIDE_PANEL_SCHEMA}`);
+  if (!plan || plan.reportSchema !== SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA}`);
+  if (!plan || plan.surfaceManagerSchema !== SURFACE_MANAGER_SCHEMA) errors.push(`surfaceManagerSchema must be ${SURFACE_MANAGER_SCHEMA}`);
+  if (!plan || plan.surfaceRecordSchema !== SURFACE_RECORD_SCHEMA) errors.push(`surfaceRecordSchema must be ${SURFACE_RECORD_SCHEMA}`);
+  if (!plan || plan.surfaceControllerSchema !== SURFACE_CONTROLLER_SCHEMA) errors.push(`surfaceControllerSchema must be ${SURFACE_CONTROLLER_SCHEMA}`);
+  if (!plan || plan.snapshotSchema !== SURFACE_SNAPSHOT_SCHEMA) errors.push(`snapshotSchema must be ${SURFACE_SNAPSHOT_SCHEMA}`);
+  if (!plan || plan.workpackage !== SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE) errors.push(`workpackage must be ${SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE}`);
+  if (!plan || plan.status !== SURFACE_MANAGER_SIDE_PANEL_STATUS) errors.push(`status must be ${SURFACE_MANAGER_SIDE_PANEL_STATUS}`);
+  if (!plan || plan.targetReadiness !== SURFACE_MANAGER_SIDE_PANEL_TARGET) errors.push(`targetReadiness must be ${SURFACE_MANAGER_SIDE_PANEL_TARGET}`);
+  if (!includesAll(plan && plan.componentTags, COMPONENT_TAGS)) errors.push('component tags missing');
+  if (!includesAll(plan && plan.managerMethods, REQUIRED_MANAGER_METHODS)) errors.push('manager methods missing');
+  if (!includesAll(plan && plan.panelMethods, REQUIRED_PANEL_METHODS)) errors.push('panel methods missing');
+  if (!includesAll(plan && plan.events, REQUIRED_EVENTS)) errors.push('events missing');
+  if (!includesAll(plan && plan.placements, REQUIRED_PLACEMENTS)) errors.push('placements missing');
+  if (!includesAll(plan && plan.modes, REQUIRED_MODES)) errors.push('modes missing');
+  if (!plan || plan.featureFlags.xSidePanelImplemented !== true) errors.push('x-side-panel must be implemented');
+  if (!plan || plan.featureFlags.dockedModeImplemented !== true) errors.push('docked mode must be implemented');
+  if (!plan || plan.featureFlags.overlayModeImplemented !== true) errors.push('overlay mode must be implemented');
+  if (!plan || plan.featureFlags.pinnedModeImplemented !== true) errors.push('pinned mode must be implemented');
+  if (!plan || plan.featureFlags.collapsedModeImplemented !== true) errors.push('collapsed mode must be implemented');
+  if (!plan || plan.featureFlags.responsiveFullscreenImplemented !== true) errors.push('responsive fullscreen mode must be implemented');
+  if (!plan || plan.featureFlags.usesControllerFromWpSm02 !== true) errors.push('WP-SM-04 must reuse WP-SM-02 controller');
+  if (!plan || plan.featureFlags.createsSecondRegistry !== false) errors.push('WP-SM-04 must not create a second registry');
+  if (!plan || plan.featureFlags.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel boundary must stay clean');
+  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: SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    workpackage: SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE,
+    targetReadiness: SURFACE_MANAGER_SIDE_PANEL_TARGET
+  };
+}
+
+function createSurfaceManagerSidePanelReport(options = {}) {
+  const plan = options.plan || createSurfaceManagerSidePanelPlan(options);
+  const validation = validateSurfaceManagerSidePanelPlan(plan);
+
+  return {
+    schema: SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    componentTags: plan.componentTags,
+    runtimeArtifacts: plan.runtimeArtifacts,
+    managerMethodCount: plan.managerMethods.length,
+    panelMethodCount: plan.panelMethods.length,
+    eventCount: plan.events.length,
+    placements: plan.placements,
+    modes: plan.modes,
+    localGate: plan.localGate,
+    packageScript: plan.packageScript,
+    usesControllerFromWpSm02: plan.featureFlags.usesControllerFromWpSm02,
+    sidePanelImplemented: plan.featureFlags.xSidePanelImplemented,
+    kernelBoundary: plan.kernelBoundary,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision
+  };
+}
+
+module.exports = {
+  COMPONENT_DOCS,
+  COMPONENT_FIXTURES,
+  COMPONENT_SUITES,
+  COMPONENT_TAGS,
+  KERNEL_BOUNDARY,
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  REQUIRED_ARTIFACTS,
+  REQUIRED_DOCS,
+  REQUIRED_EVENTS,
+  REQUIRED_MANAGER_METHODS,
+  REQUIRED_MODES,
+  REQUIRED_PANEL_METHODS,
+  REQUIRED_PLACEMENTS,
+  RUNTIME_ARTIFACTS,
+  SOURCE_ARTIFACTS,
+  SURFACE_CONTROLLER_SCHEMA,
+  SURFACE_MANAGER_SCHEMA,
+  SURFACE_MANAGER_SIDE_PANEL_CONTRACT,
+  SURFACE_MANAGER_SIDE_PANEL_DOCS,
+  SURFACE_MANAGER_SIDE_PANEL_LOCAL_GATE,
+  SURFACE_MANAGER_SIDE_PANEL_MODULE,
+  SURFACE_MANAGER_SIDE_PANEL_PACKAGE_SCRIPT,
+  SURFACE_MANAGER_SIDE_PANEL_PLAN,
+  SURFACE_MANAGER_SIDE_PANEL_REPORT_SCHEMA,
+  SURFACE_MANAGER_SIDE_PANEL_SCHEMA,
+  SURFACE_MANAGER_SIDE_PANEL_STATUS,
+  SURFACE_MANAGER_SIDE_PANEL_SUITE,
+  SURFACE_MANAGER_SIDE_PANEL_TARGET,
+  SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE,
+  SURFACE_MANAGER_SIDE_PANEL_WORKPACKAGE_DOC,
+  SURFACE_RECORD_SCHEMA,
+  SURFACE_SNAPSHOT_SCHEMA,
+  createSurfaceManagerSidePanelPlan,
+  createSurfaceManagerSidePanelReport,
+  validateSurfaceManagerSidePanelPlan
+};

package/catalog/surface-manager-stack-policy.d.ts

@@ -0,0 +1,32 @@
+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 MODAL_POLICIES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const STACK_POLICY_EVENTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_STACK_POLICY_BACKLOG: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_DIAGNOSTIC_SCHEMA: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_STACK_POLICY_FIXTURE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_STACK_POLICY_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_MODULE: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_SCHEMA: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_STATUS: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_SUITE: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_TARGET: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_STACK_POLICY_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare function createSurfaceManagerStackPolicyPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerStackPolicyReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerStackPolicyPlan(plan?: unknown): XtendCatalogReport;