@ccslabs/xtend 0.1.0-rc.1 → 0.1.2

package/xtendrmt/rmt-lifecycle-demo.core.json

@@ -31,6 +31,7 @@
       "id": "surface:xtendrmt.lifecycle.demo/source",
       "name": "source",
       "kind": "named_surface",
+      "type": "window",
       "laneRefs": [
         "lane:xtendrmt.lifecycle.demo/source/visible"
       ],
@@ -43,6 +44,7 @@
       "id": "surface:xtendrmt.lifecycle.demo/compiler",
       "name": "compiler",
       "kind": "named_surface",
+      "type": "window",
       "laneRefs": [
         "lane:xtendrmt.lifecycle.demo/compiler/critical",
         "lane:xtendrmt.lifecycle.demo/compiler/diagnostics"
@@ -56,6 +58,7 @@
       "id": "surface:xtendrmt.lifecycle.demo/scaffold",
       "name": "scaffold",
       "kind": "named_surface",
+      "type": "window",
       "laneRefs": [
         "lane:xtendrmt.lifecycle.demo/scaffold/visible"
       ],
@@ -68,6 +71,7 @@
       "id": "surface:xtendrmt.lifecycle.demo/http",
       "name": "http",
       "kind": "named_surface",
+      "type": "window",
       "laneRefs": [
         "lane:xtendrmt.lifecycle.demo/http/idle"
       ],

package/xtendrmt/rmt-lifecycle-demo.rmt-build.app.js

@@ -48,7 +48,7 @@ const BUILD_FINGERPRINT = Object.freeze({
     {
       "id": "http",
       "label": "HTTP/Test",
-      "artifact": "xtendrmt-rmt-lifecycle-demo-rmt-build.html",
+      "artifact": "tests/browser/fixtures/rmt-lifecycle-demo-rmt-build-smoke.html",
       "status": "servable"
     }
   ]

package/xtendrmt/rmt-lifecycle-demo.rmt-build.scaffold.json

@@ -14,7 +14,7 @@
   "generated": {
     "component": "components/x-rmt-lifecycle-demo-build.js",
     "app": "xtendrmt/rmt-lifecycle-demo.rmt-build.app.js",
-    "host": "xtendrmt-rmt-lifecycle-demo-rmt-build.html",
+    "host": "tests/browser/fixtures/rmt-lifecycle-demo-rmt-build-smoke.html",
     "browserSmoke": "tests/browser/fixtures/rmt-lifecycle-demo-rmt-build-smoke.html",
     "report": "xtendrmt/rmt-lifecycle-demo.rmt-build.scaffold.json"
   },
@@ -169,7 +169,7 @@
     {
       "id": "http",
       "label": "HTTP/Test",
-      "artifact": "xtendrmt-rmt-lifecycle-demo-rmt-build.html",
+      "artifact": "tests/browser/fixtures/rmt-lifecycle-demo-rmt-build-smoke.html",
       "status": "servable"
     }
   ],

package/xtendrmt/rmt-lifecycle-demo.scaffold.json

@@ -7,13 +7,13 @@
   "sourceSyntax": "rmt-vnext",
   "sourceSha256": "77ca654f845c8dd26e5c6ab58471548f24299b393baa27485653706771b06f0d",
   "coreOutput": "xtendrmt/rmt-lifecycle-demo.core.json",
-  "coreSha256": "537da4d45e582d8bd970948da92eef1a99791301f0198b05fa3cd3c457b116b9",
+  "coreSha256": "24e6ef71f8baeaa4a483c0f51895c5599ba17ace4e657d913da36644c4fc452a",
   "buildCommand": "node xtend-builder/scaffold.js rmt-lifecycle-demo --write --json",
   "localGate": "node scripts/run_xtend_tests.js rmt-lifecycle-demo --json",
   "generated": {
     "component": "components/x-rmt-lifecycle-demo.js",
     "app": "xtendrmt/rmt-lifecycle-demo.app.js",
-    "host": "xtendrmt-rmt-lifecycle-demo.html",
+    "host": "tests/browser/fixtures/rmt-lifecycle-demo-smoke.html",
     "browserSmoke": "tests/browser/fixtures/rmt-lifecycle-demo-smoke.html",
     "report": "xtendrmt/rmt-lifecycle-demo.scaffold.json"
   },
@@ -156,7 +156,7 @@
     {
       "id": "http",
       "label": "HTTP/Test",
-      "artifact": "xtendrmt-rmt-lifecycle-demo.html",
+      "artifact": "tests/browser/fixtures/rmt-lifecycle-demo-smoke.html",
       "status": "servable",
       "detail": "Host und Browser-Smoke laufen ueber den lokalen XTend Dev Server."
     }
@@ -175,7 +175,7 @@
     "compiler-emits-deterministic-core-json",
     "scaffold-writes-generated-xtend-component",
     "scaffold-writes-generated-demo-app",
-    "host-loads-over-http-dev-server",
+    "browser-smoke-loads-over-http-dev-server",
     "browser-smoke-renders-generated-app"
   ],
   "boundaries": [

package/xtendrmt/rmt-native-shell-runtime.d.ts

@@ -0,0 +1,77 @@
+export const RMT_NATIVE_SHELL_REPORT_SCHEMA: 'xtend.mm-rmt.native-shell-report.v1';
+export const RMT_NATIVE_SHELL_RUNTIME_SCHEMA: 'xtend.mm-rmt.native-shell-runtime.v1';
+
+export interface RmtNativeShellIsland {
+  id: string;
+  state: string;
+  surfaceId?: string;
+  owner?: string;
+  nodeCount: number;
+  renderCount: number;
+  focusOrder?: number;
+  lastRenderedAt?: string | null;
+}
+
+export interface RmtNativeShellRendererLike {
+  renderKeyed(root: unknown, descriptors: unknown[], options?: Record<string, unknown>): unknown[];
+}
+
+export interface RmtNativeShellSurfaceRuntimeLike {
+  materialize?(recordsBySource?: unknown[] | Record<string, unknown[]>, options?: Record<string, unknown>): {
+    createdCount?: number;
+    reusedCount?: number;
+    created?: string[];
+    reused?: string[];
+  };
+  listInstances?(options?: { includeDestroyed?: boolean }): Array<Record<string, unknown> & { id: string; state?: string }>;
+  openSurface(surfaceRef: string, options?: Record<string, unknown>): Promise<Record<string, unknown> & { id: string; state: string }>;
+  closeSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  destroySurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  minimizeSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  restoreSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  focusSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+}
+
+export interface RmtNativeShellControllerOptions {
+  renderer?: RmtNativeShellRendererLike;
+  rendererOptions?: Record<string, unknown>;
+  surfaceRuntime?: RmtNativeShellSurfaceRuntimeLike;
+  surfaceOptions?: Record<string, unknown>;
+  root?: unknown;
+  mount?: unknown;
+  descriptorFactory?: (instance: Record<string, unknown>, context: Record<string, unknown>) => unknown;
+  diagnosticsHub?: { publish(channel: string, payload: unknown, meta?: Record<string, unknown>): unknown };
+}
+
+export interface RmtNativeShellReport {
+  schema: typeof RMT_NATIVE_SHELL_REPORT_SCHEMA;
+  islandId?: string;
+  nodeCount?: number;
+  instanceCount?: number;
+  renderedCount?: number;
+  islandIds?: string[];
+  materializeReport?: Record<string, unknown>;
+  nodes?: unknown[];
+  island?: RmtNativeShellIsland;
+}
+
+export interface RmtNativeShellController {
+  schema: typeof RMT_NATIVE_SHELL_RUNTIME_SCHEMA;
+  renderer: RmtNativeShellRendererLike | null;
+  surfaceRuntime: RmtNativeShellSurfaceRuntimeLike | null;
+  renderIsland(islandRef: string | { id: string }, root: unknown, descriptors: unknown | unknown[], options?: Record<string, unknown>): RmtNativeShellReport;
+  renderIsland(islandRef: string | { id: string }, descriptors: unknown | unknown[], options?: Record<string, unknown>): RmtNativeShellReport;
+  syncSurfaces(recordsBySource?: unknown[] | Record<string, unknown[]>, options?: Record<string, unknown>): RmtNativeShellReport;
+  materializeAndRender(recordsBySource?: unknown[] | Record<string, unknown[]>, options?: Record<string, unknown>): RmtNativeShellReport;
+  openSurface(surfaceRef: string, metadata?: Record<string, unknown>): Promise<Record<string, unknown> & { id: string; state: string }>;
+  closeSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  minimizeSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  restoreSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  focusSurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  destroySurface(surfaceRef: string, metadata?: Record<string, unknown>): Record<string, unknown> & { id: string; state: string };
+  getIsland(islandRef: string): RmtNativeShellIsland | null;
+  listIslands(): RmtNativeShellIsland[];
+  listDiagnostics(): Array<Record<string, unknown>>;
+}
+
+export function createRmtNativeShellController(options?: RmtNativeShellControllerOptions): RmtNativeShellController;

package/xtendrmt/rmt-native-shell-runtime.js

@@ -0,0 +1,309 @@
+(function attachRmtNativeShellRuntime(globalTarget) {
+  const RMT_NATIVE_SHELL_RUNTIME_SCHEMA = 'xtend.mm-rmt.native-shell-runtime.v1';
+  const RMT_NATIVE_SHELL_REPORT_SCHEMA = 'xtend.mm-rmt.native-shell-report.v1';
+
+  function clampString(value, fallback = '') {
+    const normalized = String(value == null ? '' : value).trim();
+    return normalized || fallback;
+  }
+
+  function toArray(value) {
+    return Array.isArray(value) ? value : (value == null ? [] : [value]);
+  }
+
+  function objectRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  }
+
+  function cloneValue(value, fallback = null) {
+    if (typeof value === 'undefined') return fallback;
+    if (value === null || typeof value !== 'object') return value;
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_) {
+      return value;
+    }
+  }
+
+  function isNodeRoot(value) {
+    return value && typeof value === 'object' && (typeof value.replaceChildren === 'function' || typeof value.appendChild === 'function');
+  }
+
+  function createDefaultRenderer(options = {}) {
+    if (options.renderer) return options.renderer;
+    const rendererApi = globalTarget && globalTarget.XTendRmtDomDescriptorRenderer;
+    if (rendererApi && typeof rendererApi.createRmtDomDescriptorRenderer === 'function') {
+      return rendererApi.createRmtDomDescriptorRenderer(options.rendererOptions || options);
+    }
+    return null;
+  }
+
+  function createDefaultSurfaceRuntime(options = {}) {
+    if (options.surfaceRuntime) return options.surfaceRuntime;
+    const surfaceApi = globalTarget && globalTarget.XTendRmtSurfaceResourceGraphRuntime;
+    if (surfaceApi && typeof surfaceApi.createRmtSurfaceResourceGraphRuntime === 'function') {
+      return surfaceApi.createRmtSurfaceResourceGraphRuntime(options.surfaceOptions || options);
+    }
+    return null;
+  }
+
+  function keyedDescriptor(descriptor, key, attributes = {}) {
+    const source = objectRecord(descriptor);
+    return {
+      ...cloneValue(source, source),
+      key: source.key || key,
+      attributes: {
+        ...objectRecord(source.attributes),
+        ...attributes
+      }
+    };
+  }
+
+  function defaultDescriptorFactory(instance) {
+    const surface = objectRecord(instance);
+    const record = objectRecord(surface.record);
+    const baseTemplate = objectRecord(surface.template).root || (objectRecord(surface.template).type ? surface.template : null);
+    const attributes = {
+      'data-rmt-shell-island': surface.id,
+      'data-rmt-surface': surface.surfaceId,
+      'data-rmt-surface-state': surface.state,
+      'data-rmt-owner': surface.owner,
+      'aria-hidden': surface.state === 'minimized' ? 'true' : 'false'
+    };
+    if (baseTemplate) return keyedDescriptor(baseTemplate, surface.id, attributes);
+    return {
+      type: 'element',
+      tag: surface.component || 'section',
+      key: surface.id,
+      attributes,
+      children: [
+        {
+          type: 'text',
+          text: record.title || record.name || surface.id
+        }
+      ]
+    };
+  }
+
+  function createRmtNativeShellController(options = {}) {
+    const renderer = createDefaultRenderer(options);
+    const surfaceRuntime = createDefaultSurfaceRuntime(options);
+    const defaultRoot = options.root || options.mount || null;
+    const descriptorFactory = typeof options.descriptorFactory === 'function'
+      ? options.descriptorFactory
+      : defaultDescriptorFactory;
+    const islandRegistry = new Map();
+    const diagnostics = [];
+
+    function publish(code, message, details = {}) {
+      const diagnostic = {
+        schema: 'xtend.mm-rmt.native-shell-diagnostic.v1',
+        code,
+        message,
+        details: cloneValue(details, {})
+      };
+      diagnostics.push(diagnostic);
+      if (options.diagnosticsHub && typeof options.diagnosticsHub.publish === 'function') {
+        options.diagnosticsHub.publish('rmt.native_shell', diagnostic, { schema: diagnostic.schema });
+      }
+      return diagnostic;
+    }
+
+    function requireRenderer() {
+      if (renderer && typeof renderer.renderKeyed === 'function') return renderer;
+      throw new Error('RMT Native Shell Controller benoetigt einen DOM Descriptor Renderer mit renderKeyed().');
+    }
+
+    function requireSurfaceRuntime() {
+      if (surfaceRuntime) return surfaceRuntime;
+      throw new Error('RMT Native Shell Controller benoetigt eine Surface Resource Graph Runtime.');
+    }
+
+    function normalizeDescriptorList(descriptors, islandId) {
+      return toArray(descriptors).map((descriptor, index) => {
+        const record = objectRecord(descriptor);
+        const key = clampString(record.key, index === 0 ? islandId : `${islandId}:${index}`);
+        return keyedDescriptor(record, key, {
+          'data-rmt-shell-island': islandId
+        });
+      });
+    }
+
+    function upsertIsland(id, patch = {}) {
+      const islandId = clampString(id);
+      if (!islandId) return null;
+      const current = islandRegistry.get(islandId) || {
+        id: islandId,
+        state: 'materialized',
+        renderCount: 0,
+        root: null,
+        nodeCount: 0,
+        lastRenderedAt: null
+      };
+      const next = {
+        ...current,
+        ...patch
+      };
+      islandRegistry.set(islandId, next);
+      return next;
+    }
+
+    function renderIsland(islandRef, rootOrDescriptor, descriptorOrOptions, maybeOptions) {
+      const islandId = clampString(typeof islandRef === 'object' ? islandRef.id : islandRef);
+      if (!islandId) throw new Error('RMT Shell Island braucht eine stabile id.');
+      const root = isNodeRoot(rootOrDescriptor) ? rootOrDescriptor : (objectRecord(descriptorOrOptions).root || defaultRoot);
+      const descriptors = isNodeRoot(rootOrDescriptor) ? descriptorOrOptions : rootOrDescriptor;
+      const renderOptions = isNodeRoot(rootOrDescriptor) ? objectRecord(maybeOptions) : objectRecord(descriptorOrOptions);
+      if (!root) throw new Error(`RMT Shell Island ${islandId} hat keinen Mount-Root.`);
+      const list = normalizeDescriptorList(descriptors, islandId);
+      const nodes = requireRenderer().renderKeyed(root, list, renderOptions);
+      const island = upsertIsland(islandId, {
+        root,
+        nodeCount: nodes.length,
+        renderCount: (islandRegistry.get(islandId) && islandRegistry.get(islandId).renderCount || 0) + 1,
+        state: 'rendered',
+        lastRenderedAt: renderOptions.at || 'static-local'
+      });
+      publish('rmt.native_shell.island.rendered', `RMT Shell Island ${islandId} wurde gerendert.`, {
+        islandId,
+        nodeCount: nodes.length
+      });
+      return {
+        schema: RMT_NATIVE_SHELL_REPORT_SCHEMA,
+        islandId,
+        nodeCount: nodes.length,
+        nodes,
+        island: cloneValue(island, island)
+      };
+    }
+
+    function syncSurfaces(recordsBySource = {}, syncOptions = {}) {
+      const runtime = requireSurfaceRuntime();
+      const materializeReport = typeof runtime.materialize === 'function'
+        ? runtime.materialize(recordsBySource, syncOptions.materialize || syncOptions.materializeOptions || {})
+        : { createdCount: 0, reusedCount: 0, created: [], reused: [] };
+      const instances = typeof runtime.listInstances === 'function'
+        ? runtime.listInstances({ includeDestroyed: false })
+        : [];
+      const descriptors = instances.map((instance) => descriptorFactory(instance, {
+        recordsBySource,
+        options: syncOptions,
+        controller: api
+      }));
+      let nodeCount = 0;
+      if (syncOptions.root || defaultRoot) {
+        const nodes = requireRenderer().renderKeyed(syncOptions.root || defaultRoot, descriptors, {
+          ...objectRecord(syncOptions.renderOptions),
+          model: {
+            ...objectRecord(syncOptions.renderOptions && syncOptions.renderOptions.model),
+            instances
+          }
+        });
+        nodeCount = nodes.length;
+      }
+      instances.forEach((instance) => upsertIsland(instance.id, {
+        state: instance.state,
+        surfaceId: instance.surfaceId,
+        owner: instance.owner,
+        nodeCount
+      }));
+      publish('rmt.native_shell.surfaces.synced', 'RMT Surface Islands wurden synchronisiert.', {
+        instanceCount: instances.length,
+        renderedCount: nodeCount,
+        createdCount: materializeReport.createdCount,
+        reusedCount: materializeReport.reusedCount
+      });
+      return {
+        schema: RMT_NATIVE_SHELL_REPORT_SCHEMA,
+        materializeReport,
+        instanceCount: instances.length,
+        renderedCount: nodeCount,
+        islandIds: instances.map((instance) => instance.id)
+      };
+    }
+
+    async function openSurface(surfaceRef, metadata = {}) {
+      const result = await requireSurfaceRuntime().openSurface(surfaceRef, metadata);
+      upsertIsland(result.id, { state: result.state, surfaceId: result.surfaceId, owner: result.owner });
+      return result;
+    }
+
+    function closeSurface(surfaceRef, metadata = {}) {
+      const result = requireSurfaceRuntime().closeSurface(surfaceRef, metadata);
+      upsertIsland(result.id, { state: result.state, surfaceId: result.surfaceId, owner: result.owner });
+      return result;
+    }
+
+    function minimizeSurface(surfaceRef, metadata = {}) {
+      const result = requireSurfaceRuntime().minimizeSurface(surfaceRef, metadata);
+      upsertIsland(result.id, { state: result.state, surfaceId: result.surfaceId, owner: result.owner });
+      return result;
+    }
+
+    function restoreSurface(surfaceRef, metadata = {}) {
+      const result = requireSurfaceRuntime().restoreSurface(surfaceRef, metadata);
+      upsertIsland(result.id, { state: result.state, surfaceId: result.surfaceId, owner: result.owner });
+      return result;
+    }
+
+    function focusSurface(surfaceRef, metadata = {}) {
+      const result = requireSurfaceRuntime().focusSurface(surfaceRef, metadata);
+      upsertIsland(result.id, { state: result.state, surfaceId: result.surfaceId, owner: result.owner, focusOrder: result.focusOrder });
+      return result;
+    }
+
+    function destroySurface(surfaceRef, metadata = {}) {
+      const result = requireSurfaceRuntime().destroySurface(surfaceRef, metadata);
+      upsertIsland(result.id, { state: result.state, surfaceId: result.surfaceId, owner: result.owner });
+      return result;
+    }
+
+    const api = Object.freeze({
+      schema: RMT_NATIVE_SHELL_RUNTIME_SCHEMA,
+      renderer,
+      surfaceRuntime,
+      renderIsland,
+      syncSurfaces,
+      materializeAndRender: syncSurfaces,
+      openSurface,
+      closeSurface,
+      minimizeSurface,
+      restoreSurface,
+      focusSurface,
+      destroySurface,
+      getIsland(islandRef) {
+        const island = islandRegistry.get(clampString(islandRef));
+        return island ? cloneValue(island, island) : null;
+      },
+      listIslands() {
+        return [...islandRegistry.values()].map((island) => cloneValue(island, island));
+      },
+      listDiagnostics() {
+        return diagnostics.slice();
+      }
+    });
+
+    return api;
+  }
+
+  const api = {
+    RMT_NATIVE_SHELL_REPORT_SCHEMA,
+    RMT_NATIVE_SHELL_RUNTIME_SCHEMA,
+    createRmtNativeShellController
+  };
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = api;
+  }
+  if (globalTarget) {
+    globalTarget.XTendRmtNativeShellRuntime = api;
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : (typeof window !== 'undefined' ? window : this));
+
+const __XTEND_RMT_NATIVE_SHELL_RUNTIME_API__ = globalThis.XTendRmtNativeShellRuntime;
+
+export const RMT_NATIVE_SHELL_REPORT_SCHEMA = __XTEND_RMT_NATIVE_SHELL_RUNTIME_API__.RMT_NATIVE_SHELL_REPORT_SCHEMA;
+export const RMT_NATIVE_SHELL_RUNTIME_SCHEMA = __XTEND_RMT_NATIVE_SHELL_RUNTIME_API__.RMT_NATIVE_SHELL_RUNTIME_SCHEMA;
+export const createRmtNativeShellController = __XTEND_RMT_NATIVE_SHELL_RUNTIME_API__.createRmtNativeShellController;
+
+export default __XTEND_RMT_NATIVE_SHELL_RUNTIME_API__;

package/xtendrmt/rmt-node-ssr-adapter.d.ts

@@ -0,0 +1,197 @@
+import type { Readable } from 'node:stream';
+
+export const RMT_NODE_SSR_ADAPTER_SCHEMA: 'xtend.rmt.node-ssr-adapter.v1';
+export const RMT_NODE_SSR_RENDER_RESULT_SCHEMA: 'xtend.rmt.node-ssr-render-result.v1';
+export const RMT_NODE_SSR_JSONL_FRAME_SCHEMA: 'xtend.rmt.node-ssr-jsonl-frame.v1';
+export const RMT_NODE_SSR_DIAGNOSTIC_SCHEMA: 'xtend.rmt.node-ssr-diagnostic.v1';
+export const RMT_NODE_SSR_HYDRATION_SCHEMA: 'xtend.rmt.node-ssr-hydration-payload.v1';
+export const RMT_NODE_SSR_CHUNK_KIND: 'renderman_template_chunk';
+export const RMT_NODE_SSR_RESPONSE_KIND: 'renderman_template_prerender_response';
+export const RMT_NODE_SSR_EXECUTION_MODE: 'server_prerender_hydrate';
+export const RMT_NODE_SSR_STREAMING_CONTRACT_SCHEMA: 'xtend.rmt.vnext-streaming-contract.v1';
+export const RMT_NODE_SSR_KERNEL_BOUNDARY: 'no-rmt-kernel-import-of-xtend-types';
+
+export type RmtNodeSsrSeverity = 'info' | 'warning' | 'error' | 'fatal';
+
+export interface RmtNodeSsrDiagnostic {
+  schema: typeof RMT_NODE_SSR_DIAGNOSTIC_SCHEMA;
+  code: string;
+  severity: RmtNodeSsrSeverity;
+  message: string;
+  [key: string]: unknown;
+}
+
+export interface RmtNodeSsrComponentCapabilityHint {
+  tag: string;
+  family?: string;
+  visualKind?: string;
+  modulePath?: string;
+  slots?: string[];
+  parts?: string[];
+  events?: string[];
+  importPolicy?: string;
+  kernelBoundary?: string;
+}
+
+export interface RmtNodeSsrHydrationPayload {
+  schema: typeof RMT_NODE_SSR_HYDRATION_SCHEMA;
+  requestId: string;
+  executionMode: typeof RMT_NODE_SSR_EXECUTION_MODE;
+  sourceKind: string;
+  sourceRef?: string | null;
+  componentCapabilities: RmtNodeSsrComponentCapabilityHint[];
+  coreDocumentSchema?: string | null;
+  streamingContractSchema?: string | null;
+  [key: string]: unknown;
+}
+
+export interface RmtNodeSsrTemplateChunk {
+  kind: typeof RMT_NODE_SSR_CHUNK_KIND;
+  version: string;
+  executionMode: typeof RMT_NODE_SSR_EXECUTION_MODE;
+  transport: 'server' | string;
+  rootId: string;
+  template: Record<string, unknown>;
+  target: Record<string, unknown>;
+  markup: {
+    html: string;
+    textContent: string;
+    descriptor: unknown;
+  };
+  hydration: Record<string, unknown>;
+  modelSnapshot: Record<string, unknown>;
+  plan: Record<string, unknown>;
+  renderedAt: string;
+}
+
+export interface RmtNodeSsrRenderResult {
+  schema: typeof RMT_NODE_SSR_RENDER_RESULT_SCHEMA;
+  adapterSchema: typeof RMT_NODE_SSR_ADAPTER_SCHEMA;
+  ok: boolean;
+  status: 'rendered' | 'blocked' | string;
+  requestId: string;
+  html: string;
+  head: {
+    preloads: Array<Record<string, unknown>>;
+    hints: Array<Record<string, unknown>>;
+  };
+  chunks: RmtNodeSsrTemplateChunk[];
+  response: {
+    kind: typeof RMT_NODE_SSR_RESPONSE_KIND;
+    version: string;
+    executionMode: typeof RMT_NODE_SSR_EXECUTION_MODE;
+    rootId: string;
+    chunks: RmtNodeSsrTemplateChunk[];
+    hydration: RmtNodeSsrHydrationPayload;
+    diagnostics: RmtNodeSsrDiagnostic[];
+  };
+  hydration: RmtNodeSsrHydrationPayload;
+  streamingContract: Record<string, unknown> | null;
+  componentCapabilities: RmtNodeSsrComponentCapabilityHint[];
+  fabricTelemetryHints: Record<string, unknown>;
+  diagnostics: RmtNodeSsrDiagnostic[];
+}
+
+export interface RmtNodeSsrJsonlFrame {
+  schema: typeof RMT_NODE_SSR_JSONL_FRAME_SCHEMA;
+  type: 'start' | 'component' | 'html' | 'hydration' | 'diagnostic' | 'complete' | 'error' | string;
+  requestId: string;
+  sequence: number;
+  operationId: string | null;
+  variant: string | null;
+  capability: string | null;
+  lane: string | null;
+  chunkKey: string | null;
+  payload: Record<string, unknown>;
+  diagnostics: RmtNodeSsrDiagnostic[];
+}
+
+export interface RmtNodeSsrRenderInput {
+  source?: string;
+  text?: string;
+  filePath?: string;
+  sourceRef?: string;
+  coreDocument?: Record<string, unknown>;
+  core?: Record<string, unknown>;
+  descriptor?: unknown;
+  domDescriptor?: unknown;
+  template?: Record<string, unknown>;
+  preparedTemplate?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface RmtNodeSsrDataSourceRecord {
+  id: string;
+  kind?: string | null;
+  target?: string | null;
+  unsafe?: boolean;
+  format?: string | null;
+  requiresTrustBoundary?: boolean;
+  source?: Record<string, unknown>;
+}
+
+export interface RmtNodeSsrOptions {
+  requestId?: string;
+  rootId?: string;
+  namespace?: string;
+  templateId?: string;
+  renderedAt?: string;
+  model?: Record<string, unknown>;
+  selectorValues?: Record<string, unknown>;
+  manifest?: Record<string, string>;
+  sourceTexts?: Record<string, string>;
+  contracts?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  componentRegistry?: Record<string, unknown>;
+  compileRmtVNextSource?: (source: string, options?: Record<string, unknown>) => Record<string, unknown>;
+  createStreamingContract?: (coreDocument: Record<string, unknown>, options?: Record<string, unknown>) => Record<string, unknown>;
+  disableAutoCompiler?: boolean;
+  dataSources?: RmtNodeSsrDataSourceRecord[];
+  staticDataSources?: Record<string, unknown>;
+  fixtures?: Record<string, unknown>;
+  endpointHandlers?: Record<string, (record: RmtNodeSsrDataSourceRecord, context: Record<string, unknown>) => unknown | Promise<unknown>>;
+  resolveDataSource?: (record: RmtNodeSsrDataSourceRecord, context: Record<string, unknown>) => unknown | Promise<unknown>;
+  fetchAdapter?: (record: RmtNodeSsrDataSourceRecord, context: Record<string, unknown>) => unknown | Promise<unknown>;
+  sanitizeHtmlOutput?: (html: string, context: Record<string, unknown>) => string;
+  trustBoundary?: string | string[];
+  defaultTrustBoundary?: string | string[];
+  signal?: AbortSignal;
+  publishDiagnostic?: (diagnostic: RmtNodeSsrDiagnostic) => void;
+  [key: string]: unknown;
+}
+
+export interface RmtNodeSsrDescriptorRenderResult {
+  html: string;
+  componentCapabilities: RmtNodeSsrComponentCapabilityHint[];
+  diagnostics: RmtNodeSsrDiagnostic[];
+}
+
+export interface RmtNodeSsrAdapter {
+  schema: typeof RMT_NODE_SSR_ADAPTER_SCHEMA;
+  kernelBoundary: typeof RMT_NODE_SSR_KERNEL_BOUNDARY;
+  componentRegistry: Record<string, unknown> | null;
+  render(input: string | RmtNodeSsrRenderInput | unknown, options?: RmtNodeSsrOptions): Promise<RmtNodeSsrRenderResult>;
+  streamJsonl(input: string | RmtNodeSsrRenderInput | unknown, options?: RmtNodeSsrOptions): AsyncIterable<string>;
+  toReadableStream(input: string | RmtNodeSsrRenderInput | unknown, options?: RmtNodeSsrOptions): ReadableStream<string>;
+  toNodeReadable(input: string | RmtNodeSsrRenderInput | unknown, options?: RmtNodeSsrOptions): Readable;
+  renderDescriptorToHtml(descriptor: unknown, options?: RmtNodeSsrOptions): RmtNodeSsrDescriptorRenderResult;
+  listDiagnostics(): unknown[];
+}
+
+export function createRmtNodeSsrAdapter(options?: RmtNodeSsrOptions): RmtNodeSsrAdapter;
+
+declare const api: {
+  RMT_NODE_SSR_ADAPTER_SCHEMA: typeof RMT_NODE_SSR_ADAPTER_SCHEMA;
+  RMT_NODE_SSR_RENDER_RESULT_SCHEMA: typeof RMT_NODE_SSR_RENDER_RESULT_SCHEMA;
+  RMT_NODE_SSR_JSONL_FRAME_SCHEMA: typeof RMT_NODE_SSR_JSONL_FRAME_SCHEMA;
+  RMT_NODE_SSR_DIAGNOSTIC_SCHEMA: typeof RMT_NODE_SSR_DIAGNOSTIC_SCHEMA;
+  RMT_NODE_SSR_HYDRATION_SCHEMA: typeof RMT_NODE_SSR_HYDRATION_SCHEMA;
+  RMT_NODE_SSR_CHUNK_KIND: typeof RMT_NODE_SSR_CHUNK_KIND;
+  RMT_NODE_SSR_RESPONSE_KIND: typeof RMT_NODE_SSR_RESPONSE_KIND;
+  RMT_NODE_SSR_EXECUTION_MODE: typeof RMT_NODE_SSR_EXECUTION_MODE;
+  RMT_NODE_SSR_STREAMING_CONTRACT_SCHEMA: typeof RMT_NODE_SSR_STREAMING_CONTRACT_SCHEMA;
+  RMT_NODE_SSR_KERNEL_BOUNDARY: typeof RMT_NODE_SSR_KERNEL_BOUNDARY;
+  createRmtNodeSsrAdapter: typeof createRmtNodeSsrAdapter;
+};
+
+export default api;