@pulse-compute/wasm-host-runtime 0.0.0 → 1.0.0-beta.1

package/src/compiler/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const wasmHostAbi = require('./wasm-host-abi.js');
+const wasmHostBridge = require('./wasm-host-bridge.js');
+const requestResultHeaders = require('./request-result-headers.js');
+const channelBroadcaster = require('./channel-broadcaster.js');
+const jsonBody = require('./json-body.js');
+const backendCapabilities = require('./backend-capabilities.js');
+const hostRuntimeKernel = require('./host-runtime-kernel.js');
+const streamingPassthrough = require('./streaming-passthrough.js');
+const compiledWasmRuntime = require('./compiled-wasm-runtime.js');
+
+module.exports = {
+  wasmHostAbi,
+  wasmHostBridge,
+  requestResultHeaders,
+  channelBroadcaster,
+  jsonBody,
+  backendCapabilities,
+  hostRuntimeKernel,
+  streamingPassthrough,
+  compiledWasmRuntime,
+  buildWasmHostAbi: wasmHostAbi.buildWasmHostAbi,
+  buildWasmHostBridge: wasmHostBridge.buildWasmHostBridge,
+  buildRequestResultHeaders: requestResultHeaders.buildRequestResultHeaders,
+  buildChannelBroadcaster: channelBroadcaster.buildChannelBroadcaster,
+  buildJsonBodyAbi: jsonBody.buildJsonBodyAbi,
+  buildDeploymentPosture: jsonBody.buildDeploymentPosture,
+  buildBackendCapabilities: backendCapabilities.buildBackendCapabilities,
+  buildHostRuntimeKernel: hostRuntimeKernel.buildHostRuntimeKernel,
+  buildStreamingPassthrough: streamingPassthrough.buildStreamingPassthrough,
+  buildCompiledWasmRuntime: compiledWasmRuntime.buildCompiledWasmRuntime
+};

package/src/compiler/json-body.js

@@ -0,0 +1,454 @@
+'use strict';
+
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = require('@pulse-compute/wasm-contracts/diagnostics');
+const {
+  JSON_BODY_VERSION,
+  JSON_BODY_PHASE,
+  DEPLOYMENT_POSTURE_VERSION,
+  JSON_TARGETS,
+  ENGINE_TARGETS,
+  DEFAULT_JSON_MAX_BYTES,
+  JSON_ABI_EXPORTS,
+  selectRuntimeEngine,
+  selectJsonConfig
+} = loadContractsJsonBody();
+
+function loadContractsJsonBody() {
+  try {
+    return require('@pulse-compute/wasm-contracts/host/json-body');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../../contracts/src/host/json-body.js');
+    }
+    throw error;
+  }
+}
+
+function configArtifact(options = {}) {
+  return options.resolvedConfig?.artifact || options.resolvedConfig || {};
+}
+
+
+function makeDiagnostic(code, message, hint, details) {
+  return normalizeDiagnostic({
+    severity: 'error',
+    phase: 'json-body',
+    code,
+    message,
+    hint,
+    details,
+    loc: { file: '<config>' }
+  });
+}
+
+function makeWarning(code, message, hint, details) {
+  return normalizeDiagnostic({
+    severity: 'warning',
+    phase: 'json-body',
+    code,
+    message,
+    hint,
+    details,
+    loc: { file: '<config>' }
+  });
+}
+
+function validateSelections(engine, json) {
+  const diagnostics = [];
+  if (!ENGINE_TARGETS.has(engine.engine)) {
+    diagnostics.push(makeDiagnostic(
+      'PULSEWASM_ENGINE_UNSUPPORTED',
+      `Unsupported runtime.engine ${JSON.stringify(engine.engine)}.`,
+      'Use runtime.engine = "wasm" or runtime.engine = "js".',
+      { engine: engine.engine }
+    ));
+  }
+  if (!JSON_TARGETS.has(json.target)) {
+    diagnostics.push(makeDiagnostic(
+      'PULSEWASM_JSON_UNSUPPORTED_TARGET',
+      `Unsupported json.target ${JSON.stringify(json.target)}.`,
+      'Use json.target = "generic", "schema", "auto", "parser", or "none".',
+      { jsonTarget: json.target }
+    ));
+  }
+  if (!Number.isFinite(json.maxBytes) || json.maxBytes <= 0 || Math.floor(json.maxBytes) !== json.maxBytes) {
+    diagnostics.push(makeDiagnostic(
+      'PULSEWASM_JSON_BODY_LIMIT_INVALID',
+      'json.maxBytes must be a positive finite integer.',
+      `Use a positive byte limit such as ${DEFAULT_JSON_MAX_BYTES}.`,
+      { maxBytes: json.maxBytes }
+    ));
+  }
+  return diagnostics;
+}
+
+function jsonWarnings(engine, json) {
+  const warnings = [];
+  if (json.target === 'generic' && !json.explicitTarget) {
+    warnings.push(makeWarning(
+      'PULSEWASM_JSON_GENERIC_DEFAULT',
+      'Generic JSON parsing is enabled by default for ergonomics.',
+      'This can increase binary size and allocation pressure. Use json.target = "schema" or json.target = "none" for tighter builds.',
+      { target: json.target, engine: engine.engine, maxBytes: json.maxBytes }
+    ));
+  } else if (json.target === 'generic') {
+    warnings.push(makeWarning(
+      'PULSEWASM_JSON_GENERIC_SIZE_WARNING',
+      'Generic JSON parsing was selected explicitly.',
+      'Use schema JSON later if payload parsing becomes a size or latency concern.',
+      { target: json.target, engine: engine.engine, maxBytes: json.maxBytes }
+    ));
+  }
+  if (json.target === 'schema') {
+    warnings.push(makeWarning(
+      'PULSEWASM_JSON_SCHEMA_SELECTED',
+      'Schema JSON target is selected for the deterministic schema sidecar lane.',
+      'Use the schema-json sidecar or compile builders to emit parser artifacts for declared schemas.',
+      { target: json.target, schemaCount: json.schemas.length }
+    ));
+  }
+  if (json.target === 'auto') {
+    warnings.push(makeWarning(
+      'PULSEWASM_JSON_AUTO_SELECTED',
+      'Schema JSON auto mode is selected.',
+      'Declared schemas use deterministic schema sidecars; schema-less auto mode requires parser = "as-json" to emit the generic AS parser fallback.',
+      { target: json.target, schemaCount: json.schemas.length, parser: json.parser }
+    ));
+  }
+  if (json.target === 'parser') {
+    warnings.push(makeWarning(
+      'PULSEWASM_JSON_AS_GENERIC_PARSER_SELECTED',
+      'Generic AssemblyScript JSON parser mode is selected explicitly.',
+      'The parser sidecar is emitted by @pulse-compute/wasm-schema-json when schema-json-generic-parser is enabled.',
+      { target: json.target, parser: json.parser || 'as-json' }
+    ));
+  }
+  return warnings;
+}
+
+
+
+function buildMarkdown(artifact) {
+  const lines = [];
+  lines.push('# PulseWasm JSON / Body ABI Contract v1');
+  lines.push('');
+  lines.push(`Generated by: \`${artifact.generatedBy}\``);
+  lines.push(`Phase: \`${artifact.policy.phase}\``);
+  lines.push('');
+  lines.push('## Locked positions');
+  lines.push('');
+  for (const item of artifact.lockedPositions) lines.push(`- ${item}`);
+  lines.push('');
+  lines.push('## JSON target');
+  lines.push('');
+  lines.push(`- Effective target: \`${artifact.json.target}\``);
+  lines.push(`- Target source: \`${artifact.json.targetSource}\``);
+  lines.push(`- Max bytes: \`${artifact.json.maxBytes}\``);
+  lines.push('');
+  lines.push('## Body policy');
+  lines.push('');
+  lines.push(`- Request body: \`${artifact.bodyPolicy.requestBody}\``);
+  lines.push(`- Response body: \`${artifact.bodyPolicy.responseBody}\``);
+  lines.push(`- RESULT_JSON: \`${artifact.bodyPolicy.resultJson}\``);
+  lines.push(`- RESULT_BINARY: \`${artifact.bodyPolicy.resultBinary}\``);
+  lines.push('');
+  lines.push('## ABI exports');
+  lines.push('');
+  for (const item of artifact.abi.exports) lines.push(`- \`${item}\``);
+  lines.push('');
+  lines.push('## Warnings');
+  lines.push('');
+  if (artifact.warnings.length === 0) lines.push('- none');
+  for (const warning of artifact.warnings) lines.push(`- \`${warning.code}\`: ${warning.message}`);
+  lines.push('');
+  lines.push('## Schema target');
+  lines.push('');
+  lines.push('`json.target = "schema"` uses the deterministic schema sidecar lane. `json.target = "parser"` or `json.target = "auto"` without schemas can opt into the Pass 34 generic AssemblyScript parser fallback.');
+  lines.push('');
+  return `${lines.join('\n')}\n`;
+}
+
+function buildJsonBodyAbi(dispatchTable, executionPlan, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const config = configArtifact(options);
+  const engine = selectRuntimeEngine(config);
+  const json = selectJsonConfig(config);
+  const diagnostics = validateSelections(engine, json);
+  const warnings = jsonWarnings(engine, json);
+
+  const artifact = normalizeArtifact({
+    version: JSON_BODY_VERSION,
+    generatedBy,
+    source: dispatchTable?.source,
+    policy: {
+      phase: JSON_BODY_PHASE,
+      status: 'locked-contract',
+      sourceOfTruth: [
+        'pulsewasm JSON/body ABI contract v1',
+        'request-result-headers.json',
+        'wasm-host-abi.json',
+        'deployment-posture.json'
+      ],
+      payloadFeature: true,
+      routingFeature: false,
+      bodyLazy: true,
+      automaticParseDuringDispatch: false,
+      genericDefault: true,
+      schemaCompilerImplemented: false,
+      binaryBodyAbi: false,
+      fallbackAutomatic: false
+    },
+    lockedPositions: [
+      'Generic JSON is the ergonomic default.',
+      'Request body access is explicit and lazy.',
+      'The routing core never parses JSON automatically.',
+      'JSON parsing returns an explicit parse-result ref; no throw/try-catch semantics are introduced.',
+      'Invalid JSON becomes a structured PulseErrorRef with status 400.',
+      'Oversized JSON becomes a structured PulseErrorRef with status 413.',
+      'RESULT_JSON is enabled through json text response helpers.',
+      'RESULT_BINARY remains reserved.',
+      'json.target = "schema" is implemented by the schema-json sidecar/compile stream; json.target = "parser" uses the generic AS parser fallback.',
+      'json.target = "none" disables JSON helpers and should hard-fail any future JSON helper usage.'
+    ],
+    runtime: {
+      engine: engine.engine,
+      source: engine.source,
+      explicit: engine.explicit,
+      manualEscapeHatch: engine.engine === 'js',
+      automaticFallback: false
+    },
+    json: {
+      target: json.target,
+      targetSource: json.targetSource,
+      explicitTarget: json.explicitTarget,
+      maxBytes: json.maxBytes,
+      maxBytesSource: json.maxBytesSource,
+      schemas: json.schemas,
+      targets: {
+        generic: {
+          default: true,
+          parser: 'full generic parser/value model by contract; implementation dependency remains explicit in generated runtime work',
+          warning: 'binary size/allocation pressure possible'
+        },
+        schema: {
+          recognized: true,
+          implementedIn10F: false,
+          implementedBy: '@pulse-compute/wasm-schema-json schema sidecar/compile builders'
+        },
+        auto: {
+          recognized: true,
+          schemaDeclarationsPreferred: true,
+          schemaLessFallbackRequiresParser: 'as-json'
+        },
+        parser: {
+          recognized: true,
+          parser: json.parser || 'as-json',
+          implementedBy: '@pulse-compute/wasm-schema-json generic parser builder'
+        },
+        none: {
+          recognized: true,
+          jsonHelpersAvailable: false,
+          futureUsageDiagnostic: 'PULSEWASM_JSON_DISABLED'
+        }
+      }
+    },
+    bodyPolicy: {
+      requestBody: 'deferred; no automatic read, no parse-on-dispatch, explicit helper call required',
+      responseBody: 'RESULT_TEXT, RESULT_EMPTY, and RESULT_JSON text helper; RESULT_BINARY reserved',
+      resultJson: json.target === 'none' ? 'disabled by config' : 'implemented via pulse_result_json_text(ctx,status,jsonText)',
+      resultBinary: 'reserved'
+    },
+    parseResult: {
+      shape: {
+        ok: 'bool',
+        valueRef: 'JsonValueRef | 0',
+        errorRef: 'ErrorRef | 0'
+      },
+      helpers: ['pulse_json_result_ok', 'pulse_json_result_value', 'pulse_json_result_error'],
+      invalidJsonError: {
+        code: 'PULSEWASM_JSON_PARSE_ERROR',
+        message: 'Invalid JSON request body.',
+        statusCode: 400
+      },
+      bodyTooLargeError: {
+        code: 'PULSEWASM_JSON_BODY_TOO_LARGE',
+        message: 'JSON request body exceeds configured maximum size.',
+        statusCode: 413
+      }
+    },
+    valueModel: {
+      ref: 'JsonValueRef(i32)',
+      kindCodes: {
+        JSON_NULL: 0,
+        JSON_BOOL: 1,
+        JSON_NUMBER: 2,
+        JSON_STRING: 3,
+        JSON_ARRAY: 4,
+        JSON_OBJECT: 5
+      },
+      opaqueRefs: true,
+      noDynamicJsObject: true
+    },
+    abi: {
+      exports: JSON_ABI_EXPORTS,
+      implementedImmediately: [
+        'pulse_request_body_text',
+        'pulse_request_body_len',
+        'pulse_request_json_parse',
+        'pulse_json_result_ok',
+        'pulse_json_result_value',
+        'pulse_json_result_error',
+        'pulse_result_json_text'
+      ],
+      genericValueHelpers: [
+        'pulse_json_kind',
+        'pulse_json_object_has',
+        'pulse_json_object_get',
+        'pulse_json_array_len',
+        'pulse_json_array_get',
+        'pulse_json_as_string',
+        'pulse_json_as_f64',
+        'pulse_json_as_bool'
+      ],
+      reserved: ['RESULT_BINARY', 'schema-generated parser imports']
+    },
+    headers: {
+      jsonResponseContentType: 'application/json',
+      contentTypePolicy: 'pulse_result_json_text overwrites Content-Type in v1',
+      usesHeaderAbi: true
+    },
+    diagnosticsPolicy: {
+      warnings: ['PULSEWASM_JSON_GENERIC_DEFAULT', 'PULSEWASM_JSON_GENERIC_SIZE_WARNING', 'PULSEWASM_JSON_SCHEMA_RESERVED'],
+      errors: ['PULSEWASM_JSON_DISABLED', 'PULSEWASM_JSON_UNSUPPORTED_TARGET', 'PULSEWASM_JSON_BODY_LIMIT_INVALID', 'PULSEWASM_JSON_SCHEMA_NOT_FOUND'],
+      runtimeErrors: ['PULSEWASM_JSON_PARSE_ERROR', 'PULSEWASM_JSON_BODY_TOO_LARGE']
+    },
+    warnings,
+    diagnostics,
+    summary: {
+      jsonTarget: json.target,
+      engine: engine.engine,
+      genericDefault: json.target === 'generic' && !json.explicitTarget,
+      requestBodyDeferred: true,
+      jsonParseExplicit: true,
+      resultJsonImplemented: json.target !== 'none',
+      resultBinaryReserved: true,
+      schemaTargetRecognized: true,
+      schemaCompilerImplemented: false,
+      maxBytes: json.maxBytes,
+      warnings: warnings.length,
+      diagnostics: diagnostics.length
+    }
+  }, cwd);
+
+  return {
+    artifact,
+    files: [{ file: 'generated/host/json-body.md', text: buildMarkdown(artifact) }],
+    diagnostics
+  };
+}
+
+function buildDeploymentPosture(dispatchTable, executionPlan, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const config = configArtifact(options);
+  const engine = selectRuntimeEngine(config);
+  const json = selectJsonConfig(config);
+  const diagnostics = validateSelections(engine, json);
+  const debt = [];
+  if (engine.engine === 'js') {
+    debt.push({
+      code: 'PULSEWASM_ENGINE_JS_SELECTED',
+      kind: 'manual_escape_hatch',
+      feature: json.target === 'generic' ? 'generic_json' : 'runtime_engine',
+      severity: 'known_tradeoff',
+      message: 'JS engine selected manually. Application can ship, but Wasm optimization is bypassed.',
+      why: json.target === 'generic'
+        ? 'Generic JSON or dependency ergonomics were prioritized over Wasm compilation.'
+        : 'The developer explicitly selected the JS runtime engine.',
+      paydown: [
+        'Switch runtime.engine to "wasm"',
+        'Switch json.target to "schema" when generated parsers are available',
+        'Switch json.target to "none" if payload parsing is not required',
+        'Remove AssemblyScript-incompatible dependencies',
+        'Re-run pulse build with runtime.engine = "wasm"'
+      ]
+    });
+  }
+
+  const backendCapabilities = options.backendCapabilities?.artifact || options.backendCapabilities;
+  const fetchUsages = Array.isArray(backendCapabilities?.usages) ? backendCapabilities.usages : [];
+  if (engine.engine === 'js' && fetchUsages.length > 0) {
+    debt.push({
+      code: 'PULSEWASM_FETCH_REQUIRES_JS_ENGINE',
+      kind: 'manual_escape_hatch',
+      feature: 'ctx.fetch',
+      severity: 'known_tradeoff',
+      message: 'ctx.fetch was used with the JS engine escape hatch. Application can ship, but Wasm optimization is bypassed for this capability.',
+      why: 'Outbound backend requests require a future Wasm fetch-effect runtime that is not enabled yet.',
+      usages: fetchUsages.map((usage) => ({ handler: usage.handler, backend: usage.backend, method: usage.method, path: usage.path })),
+      paydown: [
+        'Enable the future Wasm fetch-effect runtime',
+        'Move backend call behind a host adaptor',
+        'Remove ctx.fetch usage from Wasm-targeted handlers',
+        'Use runtime.engine = "wasm" once fetch effects are supported'
+      ]
+    });
+  }
+
+  const artifact = normalizeArtifact({
+    version: DEPLOYMENT_POSTURE_VERSION,
+    generatedBy,
+    source: dispatchTable?.source,
+    policy: {
+      phase: JSON_BODY_PHASE,
+      manualFallbackOnly: true,
+      automaticFallback: false,
+      silentEngineSwitchForbidden: true,
+      decisionLedger: true,
+      moralizing: false
+    },
+    engine: engine.engine,
+    engineSource: engine.source,
+    optimizedTarget: 'wasm',
+    wasmOptimized: engine.engine === 'wasm',
+    manualEscapeHatch: engine.engine === 'js',
+    fallback: 'manual-only',
+    json: {
+      target: json.target,
+      targetSource: json.targetSource,
+      maxBytes: json.maxBytes,
+      genericDefault: json.target === 'generic' && !json.explicitTarget
+    },
+    debt,
+    recovery: engine.engine === 'js' ? [
+      'Use runtime.engine = "wasm" when the build is ready for the optimized path.',
+      'Use json.target = "schema" once deterministic schema parsers are generated.',
+      'Use json.target = "none" when JSON payload helpers are unnecessary.',
+      'Keep runtime.engine = "js" only as an explicit manual escape hatch.'
+    ] : [],
+    summary: {
+      engine: engine.engine,
+      wasmOptimized: engine.engine === 'wasm',
+      manualEscapeHatch: engine.engine === 'js',
+      debtCount: debt.length,
+      backendFetchUsages: fetchUsages.length,
+      jsonTarget: json.target,
+      fallbackAutomatic: false,
+      diagnostics: diagnostics.length
+    },
+    diagnostics
+  }, cwd);
+  return { artifact, diagnostics };
+}
+
+module.exports = {
+  JSON_BODY_VERSION,
+  DEPLOYMENT_POSTURE_VERSION,
+  DEFAULT_JSON_MAX_BYTES,
+  JSON_ABI_EXPORTS,
+  buildJsonBodyAbi,
+  buildDeploymentPosture,
+  selectRuntimeEngine,
+  selectJsonConfig
+};

package/src/compiler/request-result-headers.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const { PACKAGE_VERSION, normalizeArtifact } = require('@pulse-compute/wasm-contracts/diagnostics');
+const {
+  REQUEST_RESULT_HEADERS_VERSION,
+  REQUEST_RESULT_HEADERS_PHASE,
+  HEADER_ABI_EXPORTS,
+  handlerVisibleHeaderAbiExports,
+  hostResultHeaderAbiExports
+} = loadContractsRequestResultHeaders();
+
+function loadContractsRequestResultHeaders() {
+  try {
+    return require('@pulse-compute/wasm-contracts/host/request-result-headers');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../../contracts/src/host/request-result-headers.js');
+    }
+    throw error;
+  }
+}
+
+function buildMarkdown(artifact) {
+  const lines = [];
+  lines.push('# PulseWasm Request / Result / Headers Adaptor Contract v1');
+  lines.push('');
+  lines.push(`Generated by: \`${artifact.generatedBy}\``);
+  lines.push(`Phase: \`${artifact.policy.phase}\``);
+  lines.push('');
+  lines.push('## Locked positions');
+  lines.push('');
+  for (const item of artifact.lockedPositions) lines.push(`- ${item}`);
+  lines.push('');
+  lines.push('## Header storage');
+  lines.push('');
+  lines.push('- ordered entries preserve original output order');
+  lines.push('- repeated headers are preserved, not collapsed');
+  lines.push('- lookup is ASCII case-insensitive through a lowercase index key');
+  lines.push('- request headers are read-only to handlers');
+  lines.push('- response headers are mutable through set / append / delete');
+  lines.push('');
+  lines.push('## Handler-visible ABI');
+  lines.push('');
+  for (const item of artifact.abi.handlerVisibleExports) lines.push(`- \`${item}\``);
+  lines.push('');
+  lines.push('## Host result header iteration');
+  lines.push('');
+  for (const item of artifact.abi.hostResultHeaderExports) lines.push(`- \`${item}\``);
+  lines.push('');
+  lines.push('## Body policy');
+  lines.push('');
+  lines.push(`- Request body: \`${artifact.bodyPolicy.requestBody}\``);
+  lines.push(`- Response body: \`${artifact.bodyPolicy.responseBody}\``);
+  lines.push(`- JSON: \`${artifact.bodyPolicy.json}\``);
+  lines.push(`- Binary: \`${artifact.bodyPolicy.binary}\``);
+  lines.push('');
+  lines.push('## GRIP / broadcaster note');
+  lines.push('');
+  lines.push('GRIP/Fanout framing is expressed through normal response headers. The later broadcaster/GRIP adaptor inspects headers such as `Grip-Hold` and repeated `Grip-Channel` entries.');
+  lines.push('');
+  return `${lines.join('\n')}\n`;
+}
+
+function buildRequestResultHeaders(dispatchTable, executionPlan, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const artifact = normalizeArtifact({
+    version: REQUEST_RESULT_HEADERS_VERSION,
+    generatedBy,
+    source: dispatchTable?.source,
+    policy: {
+      phase: REQUEST_RESULT_HEADERS_PHASE,
+      status: 'locked-contract-and-local-bridge-proof',
+      sourceOfTruth: [
+        'wasm-host-abi.json',
+        'wasm-host-bridge.json',
+        'pulsewasm request/result/headers adaptor contract v1'
+      ],
+      headersFirstClass: true,
+      bodyDeferred: true,
+      platformBindings: false,
+      witBindings: false,
+      jsonBodyAbi: false,
+      binaryBodyAbi: false,
+      streamBodyAbi: true
+    },
+    lockedPositions: [
+      'Headers are first-class runtime artifacts.',
+      'Header storage is ordered, repeated, and case-insensitive for lookup.',
+      'Request headers are read-only to handlers.',
+      'Response headers are mutable through set / append / delete.',
+      'Header export preserves repeated headers and original order.',
+      'GRIP/Fanout framing is expressed through normal response headers.',
+      'Request body is lazy/deferred.',
+      'Text, JSON text, empty, and stream response bodies are implemented; binary buffers remain reserved.'
+    ],
+    headerStorage: {
+      entry: { name: 'string', lowerName: 'string', value: 'string' },
+      ordered: true,
+      repeated: true,
+      lookup: 'ASCII case-insensitive lowerName scan; future implementation may add index arrays',
+      request: { mutability: 'host-seeded read-only to handlers' },
+      response: { mutability: 'handler mutable', operations: ['set', 'append', 'delete'] }
+    },
+    abi: {
+      handlerVisibleExports: handlerVisibleHeaderAbiExports(),
+      hostResultHeaderExports: hostResultHeaderAbiExports(),
+      allExports: HEADER_ABI_EXPORTS
+    },
+    grip: {
+      modeledAsHeaders: true,
+      importantHeaders: ['Grip-Hold', 'Grip-Channel'],
+      repeatedGripChannelPreserved: true,
+      silentIgnoreForbidden: true
+    },
+    bodyPolicy: {
+      requestBody: 'deferred; no automatic read, no parse-on-dispatch',
+      responseBody: 'RESULT_TEXT, RESULT_JSON, RESULT_EMPTY, and RESULT_STREAM; RESULT_BINARY reserved',
+      json: 'RESULT_JSON declared/reserved, not lowered in 10D',
+      binary: 'RESULT_BINARY declared/reserved; RESULT_STREAM is the primary payload pass-through primitive'
+    },
+    summary: {
+      routes: Array.isArray(dispatchTable?.routes) ? dispatchTable.routes.length : 0,
+      executionEntries: Array.isArray(executionPlan?.entries) ? executionPlan.entries.length : 0,
+      headerAbiExports: HEADER_ABI_EXPORTS.length,
+      requestHeaderReadExports: 3,
+      responseHeaderWriteExports: 3,
+      resultHeaderIterationExports: 5,
+      repeatedHeadersPreserved: true,
+      gripHeadersModeled: true,
+      requestBodyDeferred: true,
+      responseTextAndEmptyOnly: false,
+      streamResultImplemented: true,
+      binaryReserved: true
+    }
+  }, cwd);
+
+  return {
+    artifact,
+    files: [
+      {
+        file: 'generated/host/request-result-headers.md',
+        text: buildMarkdown(artifact)
+      }
+    ],
+    diagnostics: []
+  };
+}
+
+module.exports = {
+  REQUEST_RESULT_HEADERS_VERSION,
+  buildRequestResultHeaders
+};