@ccslabs/xtend 0.1.0-rc.1

package/catalog/epic14-rmt-tooling.js

@@ -0,0 +1,282 @@
+const EPIC14_RMT_TOOLING_SCHEMA = 'xtend.epic14.rmt-tooling.v1';
+const EPIC14_RMT_TOOLING_GATE_RECORD_SCHEMA = 'xtend.epic14.rmt-tooling-gate.record.v1';
+const EPIC14_RMT_TOOLING_REPORT_SCHEMA = 'xtend.epic14.rmt-tooling-report.v1';
+const EPIC14_RMT_TOOLING_WORKPACKAGE = 'WP-E14-15';
+const EPIC14_RMT_TOOLING_STATUS = 'accepted-release-gate-handoff';
+const EPIC14_RMT_TOOLING_MODULE = 'catalog/epic14-rmt-tooling.js';
+const EPIC14_RMT_TOOLING_CONTRACT = 'development/XTend-Epic14-RMT-Tooling-Release-Gates.md';
+const EPIC14_RMT_TOOLING_WORKPACKAGE_DOC = 'development/WP-E14-15-Release-Gates-Package-Metadaten-und-CI-Handoff-vorbereiten.md';
+const EPIC14_RMT_TOOLING_DOCS = 'docs/rmt-tooling-release-gates.md';
+const EPIC14_RMT_TOOLING_SUITE = 'tests/platform/epic14_rmt_tooling_release_gates_suite.js';
+const EPIC14_RMT_TOOLING_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic14-rmt-tooling --json';
+const EPIC14_RMT_TOOLING_PACKAGE_SCRIPT = 'npm run test:epic14-rmt-tooling';
+const EPIC14_RMT_TOOLING_BUNDLE_SCRIPT = 'npm run test:rmt-tooling';
+const EPIC14_RMT_TOOLING_BUNDLE_REPORT_SCRIPT = 'npm run test:rmt-tooling:report';
+const EPIC14_RMT_TOOLING_PR_SCRIPT = 'npm run test:pr:rmt';
+const EPIC14_RMT_TOOLING_PR_REPORT_SCRIPT = 'npm run test:pr:rmt:report';
+const KERNEL_BOUNDARY = 'no-rmt-kernel-import-of-xtend-types';
+
+const RMT_TOOLING_SUITE_IDS = Object.freeze([
+  'rmt-source-model',
+  'rmt-parser',
+  'rmt-semantic-graph',
+  'rmt-linter-rules',
+  'rmt-linter-cli',
+  'rmt-completions',
+  'rmt-navigation',
+  'rmt-language-server',
+  'rmt-code-actions',
+  'rmt-agent-report',
+  'rmt-editor-packaging',
+  'rmt-language-regression',
+  'rmt-tooling-docs'
+]);
+
+const RMT_TOOLING_OPTIONAL_PR_SUITE_IDS = Object.freeze([
+  'rmt-linter-cli',
+  'rmt-language-server',
+  'rmt-language-regression',
+  'rmt-tooling-docs'
+]);
+
+const RMT_TOOLING_EXPORTS = Object.freeze([
+  './rmt-language/source-model',
+  './rmt-language/parser',
+  './rmt-language/format-adapter',
+  './rmt-language/semantic-graph',
+  './rmt-language/diagnostics',
+  './rmt-language/completions',
+  './rmt-language/hover',
+  './rmt-language/symbols',
+  './rmt-language/definitions',
+  './rmt-language/code-actions',
+  './rmt-language-server',
+  './rmt-language-server/protocol',
+  './rmt-linter/cli',
+  './rmt-linter/reporter',
+  './rmt-language/snippets',
+  './rmt-editor/vscode',
+  './catalog/epic14-rmt-tooling'
+]);
+
+const GATE_DEFINITIONS = Object.freeze([
+  {
+    id: 'rmt-tooling-pr-optional',
+    tier: 'optional-pr',
+    command: EPIC14_RMT_TOOLING_PR_SCRIPT,
+    reportCommand: EPIC14_RMT_TOOLING_PR_REPORT_SCRIPT,
+    reportPath: '.xtend-test-results/xtend-rmt-pr-gate-report.json',
+    artifactName: 'xtend-rmt-pr-gate-report-node-26',
+    suiteIds: RMT_TOOLING_OPTIONAL_PR_SUITE_IDS.slice(),
+    required: false,
+    localOnly: true,
+    validates: ['linter-cli', 'lsp-diagnostics', 'regression-matrix', 'tooling-docs']
+  },
+  {
+    id: 'rmt-tooling-release',
+    tier: 'release',
+    command: EPIC14_RMT_TOOLING_BUNDLE_SCRIPT,
+    reportCommand: EPIC14_RMT_TOOLING_BUNDLE_REPORT_SCRIPT,
+    reportPath: '.xtend-test-results/xtend-rmt-tooling-gate-report.json',
+    artifactName: 'xtend-rmt-tooling-gate-report-node-26',
+    suiteIds: RMT_TOOLING_SUITE_IDS.slice(),
+    required: true,
+    localOnly: true,
+    validates: ['source-model', 'parser', 'semantic-graph', 'linter', 'completion', 'navigation', 'lsp', 'code-actions', 'agent-report', 'editor-packaging', 'regression', 'docs']
+  },
+  {
+    id: 'rmt-tooling-package-surface',
+    tier: 'release',
+    command: EPIC14_RMT_TOOLING_LOCAL_GATE,
+    reportCommand: EPIC14_RMT_TOOLING_LOCAL_GATE,
+    reportPath: '.xtend-test-results/xtend-epic14-rmt-tooling-report.json',
+    artifactName: 'xtend-epic14-rmt-tooling-report-node-26',
+    suiteIds: ['epic14-rmt-tooling'],
+    required: true,
+    localOnly: true,
+    validates: ['package-scripts', 'exports', 'scaffold-config', 'reference-registry', 'ci-handoff']
+  }
+]);
+
+function unique(values) {
+  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean)));
+}
+
+function commandForSuites(suiteIds, reportPath) {
+  const command = `node scripts/run_xtend_tests.js ${suiteIds.join(' ')}`;
+  return reportPath ? `${command} --report ${reportPath}` : command;
+}
+
+function createGateRecord(definition) {
+  return {
+    schema: EPIC14_RMT_TOOLING_GATE_RECORD_SCHEMA,
+    ...definition,
+    suiteIds: unique(definition.suiteIds),
+    validates: unique(definition.validates)
+  };
+}
+
+function summarizeGates(gates) {
+  return gates.reduce((summary, gate) => {
+    summary.byTier[gate.tier] = (summary.byTier[gate.tier] || 0) + 1;
+    summary.suiteCount += gate.suiteIds.length;
+    return summary;
+  }, {
+    gateCount: gates.length,
+    suiteCount: 0,
+    byTier: {}
+  });
+}
+
+function createEpic14RmtToolingGatePlan(options = {}) {
+  const gates = GATE_DEFINITIONS.map(createGateRecord);
+
+  return {
+    schema: EPIC14_RMT_TOOLING_SCHEMA,
+    gateRecordSchema: EPIC14_RMT_TOOLING_GATE_RECORD_SCHEMA,
+    reportSchema: EPIC14_RMT_TOOLING_REPORT_SCHEMA,
+    workpackage: EPIC14_RMT_TOOLING_WORKPACKAGE,
+    status: EPIC14_RMT_TOOLING_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    kernelBoundary: KERNEL_BOUNDARY,
+    module: EPIC14_RMT_TOOLING_MODULE,
+    contract: EPIC14_RMT_TOOLING_CONTRACT,
+    workpackageDocument: EPIC14_RMT_TOOLING_WORKPACKAGE_DOC,
+    docs: EPIC14_RMT_TOOLING_DOCS,
+    suite: EPIC14_RMT_TOOLING_SUITE,
+    localGate: EPIC14_RMT_TOOLING_LOCAL_GATE,
+    packageScript: EPIC14_RMT_TOOLING_PACKAGE_SCRIPT,
+    bundleScript: EPIC14_RMT_TOOLING_BUNDLE_SCRIPT,
+    bundleReportScript: EPIC14_RMT_TOOLING_BUNDLE_REPORT_SCRIPT,
+    optionalPrCommand: EPIC14_RMT_TOOLING_PR_SCRIPT,
+    optionalPrReportCommand: EPIC14_RMT_TOOLING_PR_REPORT_SCRIPT,
+    releaseCommand: EPIC14_RMT_TOOLING_BUNDLE_SCRIPT,
+    releaseReportCommand: EPIC14_RMT_TOOLING_BUNDLE_REPORT_SCRIPT,
+    fullReleaseCommand: 'npm run test:release:full:report',
+    primarySuiteIds: RMT_TOOLING_SUITE_IDS.slice(),
+    optionalPrSuiteIds: RMT_TOOLING_OPTIONAL_PR_SUITE_IDS.slice(),
+    exportSurface: RMT_TOOLING_EXPORTS.slice(),
+    gates,
+    summary: summarizeGates(gates),
+    ciHandoff: {
+      optionalPrGate: {
+        command: EPIC14_RMT_TOOLING_PR_SCRIPT,
+        reportCommand: EPIC14_RMT_TOOLING_PR_REPORT_SCRIPT,
+        suiteIds: RMT_TOOLING_OPTIONAL_PR_SUITE_IDS.slice()
+      },
+      releaseGate: {
+        command: EPIC14_RMT_TOOLING_BUNDLE_SCRIPT,
+        reportCommand: EPIC14_RMT_TOOLING_BUNDLE_REPORT_SCRIPT,
+        suiteIds: RMT_TOOLING_SUITE_IDS.slice()
+      },
+      defaultReleaseGate: 'npm test'
+    },
+    networkRequired: false,
+    requiredPackageScripts: [
+      'test:rmt-linter',
+      'test:rmt-language-server',
+      'test:rmt-tooling',
+      'test:rmt-tooling:report',
+      'test:pr:rmt',
+      'test:pr:rmt:report',
+      'test:epic14-rmt-tooling'
+    ],
+    requiredFollowUps: ['WP-E14-16']
+  };
+}
+
+function validateEpic14RmtToolingGatePlan(plan) {
+  const failures = [];
+
+  if (!plan || plan.schema !== EPIC14_RMT_TOOLING_SCHEMA) {
+    failures.push('schema');
+  }
+  if (plan && plan.workpackage !== EPIC14_RMT_TOOLING_WORKPACKAGE) {
+    failures.push('workpackage');
+  }
+  if (plan && plan.kernelBoundary !== KERNEL_BOUNDARY) {
+    failures.push('kernelBoundary');
+  }
+  if (!plan || plan.networkRequired !== false) {
+    failures.push('networkRequired');
+  }
+  RMT_TOOLING_SUITE_IDS.forEach((suiteId) => {
+    if (!plan || !plan.primarySuiteIds.includes(suiteId)) {
+      failures.push(`primarySuite:${suiteId}`);
+    }
+  });
+  RMT_TOOLING_OPTIONAL_PR_SUITE_IDS.forEach((suiteId) => {
+    if (!plan || !plan.optionalPrSuiteIds.includes(suiteId)) {
+      failures.push(`optionalPrSuite:${suiteId}`);
+    }
+  });
+  RMT_TOOLING_EXPORTS.forEach((exportKey) => {
+    if (!plan || !plan.exportSurface.includes(exportKey)) {
+      failures.push(`export:${exportKey}`);
+    }
+  });
+  (plan && plan.gates || []).forEach((gate) => {
+    if (gate.schema !== EPIC14_RMT_TOOLING_GATE_RECORD_SCHEMA) {
+      failures.push(`gateSchema:${gate.id}`);
+    }
+    if (!gate.command || !Array.isArray(gate.suiteIds)) {
+      failures.push(`gateShape:${gate.id}`);
+    }
+    if (gate.localOnly !== true) {
+      failures.push(`localOnly:${gate.id}`);
+    }
+  });
+
+  return {
+    schema: EPIC14_RMT_TOOLING_REPORT_SCHEMA,
+    ok: failures.length === 0,
+    failures
+  };
+}
+
+function createEpic14RmtToolingGateReport(options = {}) {
+  const plan = options.plan || createEpic14RmtToolingGatePlan(options);
+  const validation = validateEpic14RmtToolingGatePlan(plan);
+
+  return {
+    schema: EPIC14_RMT_TOOLING_REPORT_SCHEMA,
+    ok: validation.ok,
+    workpackage: EPIC14_RMT_TOOLING_WORKPACKAGE,
+    status: validation.ok ? 'passed' : 'failed',
+    localGate: EPIC14_RMT_TOOLING_LOCAL_GATE,
+    bundleCommand: commandForSuites(plan.primarySuiteIds),
+    bundleReportCommand: commandForSuites(plan.primarySuiteIds, '.xtend-test-results/xtend-rmt-tooling-gate-report.json'),
+    optionalPrCommand: commandForSuites(plan.optionalPrSuiteIds),
+    optionalPrReportCommand: commandForSuites(plan.optionalPrSuiteIds, '.xtend-test-results/xtend-rmt-pr-gate-report.json'),
+    failures: validation.failures,
+    gateCount: plan.gates.length,
+    suiteCount: plan.primarySuiteIds.length,
+    exportCount: plan.exportSurface.length
+  };
+}
+
+module.exports = {
+  EPIC14_RMT_TOOLING_BUNDLE_REPORT_SCRIPT,
+  EPIC14_RMT_TOOLING_BUNDLE_SCRIPT,
+  EPIC14_RMT_TOOLING_CONTRACT,
+  EPIC14_RMT_TOOLING_DOCS,
+  EPIC14_RMT_TOOLING_GATE_RECORD_SCHEMA,
+  EPIC14_RMT_TOOLING_LOCAL_GATE,
+  EPIC14_RMT_TOOLING_MODULE,
+  EPIC14_RMT_TOOLING_PACKAGE_SCRIPT,
+  EPIC14_RMT_TOOLING_PR_REPORT_SCRIPT,
+  EPIC14_RMT_TOOLING_PR_SCRIPT,
+  EPIC14_RMT_TOOLING_REPORT_SCHEMA,
+  EPIC14_RMT_TOOLING_SCHEMA,
+  EPIC14_RMT_TOOLING_STATUS,
+  EPIC14_RMT_TOOLING_SUITE,
+  EPIC14_RMT_TOOLING_WORKPACKAGE,
+  EPIC14_RMT_TOOLING_WORKPACKAGE_DOC,
+  KERNEL_BOUNDARY,
+  RMT_TOOLING_EXPORTS,
+  RMT_TOOLING_OPTIONAL_PR_SUITE_IDS,
+  RMT_TOOLING_SUITE_IDS,
+  createEpic14RmtToolingGatePlan,
+  createEpic14RmtToolingGateReport,
+  validateEpic14RmtToolingGatePlan
+};

package/catalog/surface-manager-adapter-runtime.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 REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const RUNTIME_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_ADAPTER_DIAGNOSTICS: 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_MANAGER_ADAPTER_RUNTIME_BACKLOG: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_FIXTURE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_MODULE: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_SCHEMA: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_STATUS: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_SUITE: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_SCHEMA: string;
+export declare const SURFACE_RECORD_SCHEMA: string;
+export declare const SURFACE_SNAPSHOT_SCHEMA: string;
+export declare function createSurfaceManagerAdapterRuntimePlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerAdapterRuntimeReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerAdapterRuntimePlan(plan?: unknown): XtendCatalogReport;

package/catalog/surface-manager-adapter-runtime.js

@@ -0,0 +1,203 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+
+const SURFACE_MANAGER_ADAPTER_RUNTIME_SCHEMA = 'xtend.surface.adapter-runtime.v1';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA = 'xtend.surface.adapter-runtime-report.v1';
+const SURFACE_ADAPTER_SCHEMA = 'xtend.surface.adapter.v1';
+const SURFACE_ADAPTER_ID = 'xtend.surface';
+const SURFACE_ADAPTER_KIND = 'surface_adapter';
+const SURFACE_MANAGER_SCHEMA = 'xtend.surface.manager.v1';
+const SURFACE_CONTROLLER_SCHEMA = 'xtend.surface.controller.v1';
+const SURFACE_RECORD_SCHEMA = 'xtend.surface.record.v1';
+const SURFACE_SNAPSHOT_SCHEMA = 'xtend.surface.snapshot.v1';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE = 'WP-SM-10';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_STATUS = 'implemented-surface-adapter-runtime';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET = 'productive-xtend-surface-host-adapter-ready';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_MODULE = 'catalog/surface-manager-adapter-runtime.js';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_SUITE = 'tests/rmt/surface_manager_adapter_runtime_suite.js';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_BACKLOG = 'development/BACKLOG-XTend-SurfaceManager-App-Shell-und-RMT-Surface-Runtime.md';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE_DOC = 'development/WP-SM-10-Produktive-xtend-surface-Adapter-Runtime-bauen.md';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_FIXTURE = 'tests/fixtures/rmt-surface-native-domain.rmt';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_LOCAL_GATE = 'node scripts/run_xtend_tests.js surface-adapter-runtime --json';
+const SURFACE_MANAGER_ADAPTER_RUNTIME_PACKAGE_SCRIPT = 'npm run test:surface-adapter-runtime';
+
+const SURFACE_ADAPTER_OPERATIONS = Object.freeze([
+  'registerSurface',
+  'openSurface',
+  'closeSurface',
+  'focusSurface',
+  'moveSurface',
+  'resizeSurface',
+  'dockSurface',
+  'undockSurface',
+  'snapshotSurfaces',
+  'emitDiagnostic'
+]);
+
+const SURFACE_ADAPTER_DIAGNOSTICS = Object.freeze([
+  'rmt.surface.missing_id',
+  'rmt.surface.missing_manager',
+  'rmt.surface.missing_component',
+  'rmt.surface.target.missing',
+  'rmt.surface.target.unsupported',
+  'rmt.surface.operation.skipped',
+  'rmt.surface.diagnostic'
+]);
+
+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',
+  'xtendrmt/rmt-manifest.json'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  SURFACE_MANAGER_ADAPTER_RUNTIME_MODULE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_SUITE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_BACKLOG,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_FIXTURE,
+  ...RUNTIME_ARTIFACTS
+]);
+
+function includesAll(values, required) {
+  return required.every((entry) => Array.isArray(values) && values.includes(entry));
+}
+
+function createSurfaceManagerAdapterRuntimePlan(options = {}) {
+  return {
+    schema: SURFACE_MANAGER_ADAPTER_RUNTIME_SCHEMA,
+    reportSchema: SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA,
+    adapterSchema: SURFACE_ADAPTER_SCHEMA,
+    adapterId: SURFACE_ADAPTER_ID,
+    adapterKind: SURFACE_ADAPTER_KIND,
+    surfaceManagerSchema: SURFACE_MANAGER_SCHEMA,
+    surfaceControllerSchema: SURFACE_CONTROLLER_SCHEMA,
+    surfaceRecordSchema: SURFACE_RECORD_SCHEMA,
+    snapshotSchema: SURFACE_SNAPSHOT_SCHEMA,
+    workpackage: SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE,
+    status: SURFACE_MANAGER_ADAPTER_RUNTIME_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    targetReadiness: SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET,
+    module: SURFACE_MANAGER_ADAPTER_RUNTIME_MODULE,
+    suite: SURFACE_MANAGER_ADAPTER_RUNTIME_SUITE,
+    backlog: SURFACE_MANAGER_ADAPTER_RUNTIME_BACKLOG,
+    workpackageDocument: SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE_DOC,
+    fixture: SURFACE_MANAGER_ADAPTER_RUNTIME_FIXTURE,
+    localGate: SURFACE_MANAGER_ADAPTER_RUNTIME_LOCAL_GATE,
+    packageScript: SURFACE_MANAGER_ADAPTER_RUNTIME_PACKAGE_SCRIPT,
+    runtimeFactory: 'createRmtSurfaceAdapter',
+    legacyRuntimeFactory: 'createRenderManSurfaceAdapter',
+    runtimeArtifacts: RUNTIME_ARTIFACTS.slice(),
+    requiredArtifacts: REQUIRED_ARTIFACTS.slice(),
+    operations: SURFACE_ADAPTER_OPERATIONS.slice(),
+    diagnostics: SURFACE_ADAPTER_DIAGNOSTICS.slice(),
+    consumes: [
+      'surfaces[*]',
+      'components[*]',
+      'routes[*]',
+      'schedules[*]',
+      'xtend.surface.manager.v1',
+      'xtend.surface.controller.v1'
+    ],
+    runtimeBoundary: {
+      materializesDom: false,
+      claimsProductiveAdapterRuntime: true,
+      createsSecondRegistry: false,
+      kernelVisible: false,
+      rmtKernelImportsXtendTypes: false,
+      remoteRuntimeExecution: false,
+      managerTargetRequiredForOperations: true
+    },
+    nextWorkpackage: 'WP-SM-11',
+    nextDecision: 'native-surfaces-template-materialization',
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function validateSurfaceManagerAdapterRuntimePlan(plan = createSurfaceManagerAdapterRuntimePlan()) {
+  const errors = [];
+
+  if (!plan || plan.schema !== SURFACE_MANAGER_ADAPTER_RUNTIME_SCHEMA) errors.push(`schema must be ${SURFACE_MANAGER_ADAPTER_RUNTIME_SCHEMA}`);
+  if (!plan || plan.reportSchema !== SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA) errors.push(`reportSchema must be ${SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_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.adapterKind !== SURFACE_ADAPTER_KIND) errors.push(`adapterKind must be ${SURFACE_ADAPTER_KIND}`);
+  if (!plan || plan.workpackage !== SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE) errors.push(`workpackage must be ${SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE}`);
+  if (!plan || plan.status !== SURFACE_MANAGER_ADAPTER_RUNTIME_STATUS) errors.push(`status must be ${SURFACE_MANAGER_ADAPTER_RUNTIME_STATUS}`);
+  if (!plan || plan.targetReadiness !== SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET) errors.push(`targetReadiness must be ${SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET}`);
+  if (!includesAll(plan && plan.operations, SURFACE_ADAPTER_OPERATIONS)) errors.push('surface adapter operations missing');
+  if (!includesAll(plan && plan.diagnostics, SURFACE_ADAPTER_DIAGNOSTICS)) errors.push('surface adapter diagnostics missing');
+  if (!includesAll(plan && plan.runtimeArtifacts, RUNTIME_ARTIFACTS)) errors.push('runtime artifacts missing');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.claimsProductiveAdapterRuntime !== true) errors.push('productive adapter runtime must be claimed by WP-SM-10');
+  if (!plan || !plan.runtimeBoundary || plan.runtimeBoundary.createsSecondRegistry !== false) errors.push('surface adapter 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.runtimeBoundary || plan.runtimeBoundary.materializesDom !== false) errors.push('WP-SM-10 must not absorb WP-SM-11 materialization');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+
+  return {
+    schema: SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors,
+    checkedAt: 'static-local',
+    workpackage: SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE,
+    targetReadiness: SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET
+  };
+}
+
+function createSurfaceManagerAdapterRuntimeReport(options = {}) {
+  const plan = options.plan || createSurfaceManagerAdapterRuntimePlan(options);
+  const validation = validateSurfaceManagerAdapterRuntimePlan(plan);
+
+  return {
+    schema: SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    workpackage: plan.workpackage,
+    status: plan.status,
+    targetReadiness: plan.targetReadiness,
+    adapterId: plan.adapterId,
+    adapterKind: plan.adapterKind,
+    runtimeFactory: plan.runtimeFactory,
+    operationCount: plan.operations.length,
+    diagnosticCount: plan.diagnostics.length,
+    runtimeArtifacts: plan.runtimeArtifacts.slice(),
+    localGate: plan.localGate,
+    packageScript: plan.packageScript,
+    kernelBoundary: plan.kernelBoundary,
+    nextWorkpackage: plan.nextWorkpackage,
+    nextDecision: plan.nextDecision
+  };
+}
+
+module.exports = {
+  KERNEL_BOUNDARY,
+  REQUIRED_ARTIFACTS,
+  RUNTIME_ARTIFACTS,
+  SURFACE_ADAPTER_DIAGNOSTICS,
+  SURFACE_ADAPTER_ID,
+  SURFACE_ADAPTER_KIND,
+  SURFACE_ADAPTER_OPERATIONS,
+  SURFACE_ADAPTER_SCHEMA,
+  SURFACE_CONTROLLER_SCHEMA,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_BACKLOG,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_FIXTURE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_LOCAL_GATE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_MODULE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_PACKAGE_SCRIPT,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_REPORT_SCHEMA,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_SCHEMA,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_STATUS,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_SUITE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_TARGET,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE,
+  SURFACE_MANAGER_ADAPTER_RUNTIME_WORKPACKAGE_DOC,
+  SURFACE_MANAGER_SCHEMA,
+  SURFACE_RECORD_SCHEMA,
+  SURFACE_SNAPSHOT_SCHEMA,
+  createSurfaceManagerAdapterRuntimePlan,
+  createSurfaceManagerAdapterRuntimeReport,
+  validateSurfaceManagerAdapterRuntimePlan
+};

package/catalog/surface-manager-browser-lab.d.ts

@@ -0,0 +1,39 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const APP_SHELL_PROBES: XtendCatalogConstant;
+export declare const DOCS_APP_REFERENCE: XtendCatalogConstant;
+export declare const DOCS_RMT_REFERENCE: XtendCatalogConstant;
+export declare const KERNEL_BOUNDARY: XtendCatalogConstant;
+export declare const PERFORMANCE_BUDGETS: XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_BROWSER_LAB_BACKLOG: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_CLS_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const SURFACE_MANAGER_BROWSER_LAB_FIXTURE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_BROWSER_LAB_LOCAL_GATE: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_MODULE: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_PACKAGE_SCRIPT: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_PERFORMANCE_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_REPORT_SCHEMA: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_SCHEMA: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_STATUS: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_SUITE: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_TARGET: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_VISUAL_BASELINE: XtendCatalogConstant;
+export declare const SURFACE_MANAGER_BROWSER_LAB_VISUAL_BASELINE_SCHEMA: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_WORKPACKAGE: string;
+export declare const SURFACE_MANAGER_BROWSER_LAB_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const VISUAL_SNAPSHOT_IDS: XtendCatalogConstant;
+export declare const VISUAL_STATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const WORKBENCH_REFERENCE: XtendCatalogConstant;
+export declare function createSurfaceManagerBrowserLabPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createSurfaceManagerBrowserLabReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateSurfaceManagerBrowserLabPlan(plan?: unknown): XtendCatalogReport;