@pulse-compute/provider-fastly 0.0.0 → 1.0.0-beta.1

package/src/compiler/fastly-adapter.js

@@ -0,0 +1,564 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { getDefaultArtifactsDir } = require('@pulse-compute/wasm-build-support/artifacts-dir');
+const { spawnSync } = require('node:child_process');
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = loadContractsDiagnostics();
+
+
+function loadContractsDiagnostics() {
+  try {
+    return require('@pulse-compute/wasm-contracts/diagnostics');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../../../wasm/packages/contracts/src/diagnostics.js');
+    }
+    throw error;
+  }
+}
+
+const PHASE = '13C';
+const FASTLY_ADAPTER_VERSION = 'pulsewasm.fastly-adapter.v1';
+const FASTLY_STREAM_HEADER_ADAPTER_VERSION = 'pulsewasm.fastly-stream-header-adapter.v1';
+const FASTLY_LOCAL_SMOKE_VERSION = 'pulsewasm.fastly-local-smoke.v1';
+const FASTLY_PACKAGING_SMOKE_VERSION = 'pulsewasm.fastly-packaging-smoke.v1';
+const FASTLY_DEPLOYMENT_READINESS_VERSION = 'pulsewasm.fastly-deployment-readiness.v1';
+
+function sha256Text(text) { return crypto.createHash('sha256').update(String(text || ''), 'utf8').digest('hex'); }
+function sha256Buffer(buffer) { return crypto.createHash('sha256').update(buffer).digest('hex'); }
+function makeFile(file, text) { return { file, text, bytes: Buffer.byteLength(text, 'utf8'), sha256: sha256Text(text) }; }
+function normalizeSlash(value) { return String(value || '').replace(/\\/g, '/'); }
+function diag(code, message, hint, details) {
+  return normalizeDiagnostic({ phase: 'fastly-adapter', severity: 'error', code, message, hint, details, loc: { file: '<fastly-adapter>' } });
+}
+function warn(code, message, hint, details) {
+  return normalizeDiagnostic({ phase: 'fastly-adapter', severity: 'warning', code, message, hint, details, loc: { file: '<fastly-adapter>' } });
+}
+function fileRecord(filePath, cwd, kind) {
+  const buffer = fs.readFileSync(filePath);
+  return { file: normalizeSlash(path.relative(cwd, filePath)), kind, bytes: buffer.length, sha256: sha256Buffer(buffer) };
+}
+function findFile(files, fileName) {
+  return (files || []).find((file) => file.file === fileName || file.file.endsWith(`/${fileName}`));
+}
+function findOutputFile(outputFiles, suffix) {
+  return (outputFiles || []).find((file) => file.file && file.file.endsWith(suffix));
+}
+
+function buildFastlyAdapterSource() {
+  return `/* Generated by PulseWasm.
+ * Fastly stream/header adapter proof.
+ * This is a platform-shape adapter over the compiled-Wasm host runtime.
+ * It is not an official Fastly SDK and does not redefine PulseWasm semantics.
+ */
+'use strict';
+
+function normalizeRawHeaders(rawHeaders) {
+  if (!rawHeaders) return [];
+  const headers = [];
+  if (Array.isArray(rawHeaders)) {
+    if (rawHeaders.length > 0 && Array.isArray(rawHeaders[0])) {
+      for (const pair of rawHeaders) if (pair && pair.length >= 2) headers.push([String(pair[0]), String(pair[1])]);
+      return headers;
+    }
+    for (let i = 0; i < rawHeaders.length; i += 2) {
+      if (rawHeaders[i] !== undefined && rawHeaders[i + 1] !== undefined) headers.push([String(rawHeaders[i]), String(rawHeaders[i + 1])]);
+    }
+  }
+  return headers;
+}
+
+function normalizeHeaders(headers) {
+  if (!headers) return [];
+  if (Array.isArray(headers)) return normalizeRawHeaders(headers);
+  if (headers && typeof headers[Symbol.iterator] === 'function') return Array.from(headers, ([key, value]) => [String(key), String(value)]);
+  return Object.entries(headers).flatMap(([key, value]) => Array.isArray(value) ? value.map((item) => [String(key), String(item)]) : [[String(key), String(value)]]);
+}
+
+function normalizeFastlyPath(request) {
+  if (!request) return '/';
+  if (request.path) return String(request.path || '/');
+  if (request.url) {
+    try { return new URL(String(request.url), 'http://fastly.local').pathname || '/'; } catch (_) { return String(request.url || '/'); }
+  }
+  return '/';
+}
+
+function fastlyRequestToHostRequest(request) {
+  return {
+    method: String((request && request.method) || 'GET').toUpperCase(),
+    path: normalizeFastlyPath(request),
+    headers: normalizeRawHeaders(request && request.rawHeaders).concat(normalizeHeaders(request && request.headers)),
+    bodyText: request && request.bodyText !== undefined ? String(request.bodyText) : undefined
+  };
+}
+
+function groupHeaderValues(headers, name) {
+  const lower = String(name).toLowerCase();
+  return (headers || []).filter(([key]) => String(key).toLowerCase() === lower).map(([, value]) => String(value));
+}
+
+function fastlyBodyFromHostResult(result) {
+  if (!result) return '';
+  if (result.kind === 'stream') {
+    if (result.bodyStream && Array.isArray(result.bodyStream.chunks)) return result.bodyStream.chunks.join('');
+    if (result.response && result.response.bodyStream && Array.isArray(result.response.bodyStream.chunks)) return result.response.bodyStream.chunks.join('');
+    if (result.stream && Array.isArray(result.stream.chunks)) return result.stream.chunks.join('');
+    return '';
+  }
+  if (result.body === undefined || result.body === null) return '';
+  return Buffer.isBuffer(result.body) ? result.body.toString('utf8') : String(result.body);
+}
+
+function hostResultToFastlyResponse(result) {
+  const headers = (result && Array.isArray(result.headers)) ? result.headers.map(([key, value]) => [String(key), String(value)]) : [];
+  return {
+    status: Number(result && result.status) || 500,
+    kind: result && result.kind || 'unknown',
+    headers,
+    body: fastlyBodyFromHostResult(result),
+    responseRef: result && result.responseRef || 0,
+    streamRef: result && result.streamRef || 0,
+    bodyStream: result && (result.bodyStream || (result.response && result.response.bodyStream) || result.stream),
+    diagnostics: result && result.diagnostics || []
+  };
+}
+
+function createFastlyStreamHeaderAdapter(options) {
+  const runtime = options && options.runtime;
+  if (!runtime || typeof runtime.executeRequest !== 'function') {
+    const error = new Error('Fastly adapter requires a PulseWasm compiled host runtime.');
+    error.code = 'PULSEWASM_FASTLY_RUNTIME_REQUIRED';
+    throw error;
+  }
+  const observed = { requests: [], responses: [] };
+  return {
+    observed,
+    executeRequest(request) {
+      const hostRequest = fastlyRequestToHostRequest(request);
+      observed.requests.push(hostRequest);
+      const hostResult = runtime.executeRequest(hostRequest);
+      const fastlyResponse = hostResultToFastlyResponse(hostResult);
+      observed.responses.push(fastlyResponse);
+      return fastlyResponse;
+    },
+    handleRequest(request) { return this.executeRequest(request); },
+    executeConnect(input) { return runtime.executeConnect ? runtime.executeConnect(input || {}) : { status: 204, headers: [], kind: 'empty' }; },
+    executeDisconnect(input) { return runtime.executeDisconnect ? runtime.executeDisconnect(input || {}) : { status: 204, headers: [], kind: 'empty' }; }
+  };
+}
+
+module.exports = {
+  createFastlyStreamHeaderAdapter,
+  fastlyRequestToHostRequest,
+  hostResultToFastlyResponse,
+  normalizeRawHeaders,
+  normalizeHeaders,
+  normalizeFastlyPath,
+  groupHeaderValues
+};
+`;
+}
+
+function buildFastlyToml() {
+  return `manifest_version = 3
+name = "pulsewasm-fastly-proof"
+description = "PulseWasm Fastly stream/header adapter proof scaffold."
+language = "other"
+
+[scripts]
+build = "echo 'PulseWasm custom build: use fastly compute pack --wasm-binary artifacts/generated/fastly/pulsewasm-compute.wasm'"
+`;
+}
+
+function buildFastlyReadme() {
+  return `# PulseWasm Fastly Scaffold
+
+This scaffold is generated for the Fastly stream/header adapter proof.
+
+It keeps the SDK posture locked:
+
+- Fastly SDKs are references, not dependencies.
+- The old AssemblyScript SDK is not revived.
+- The custom hostcall path is vendor-unsupported and recorded as risk.
+- This scaffold is intended for local packaging/testing once the Fastly CLI can run its local Compute lifecycle.
+
+## Candidate pack command
+
+\`\`\`bash
+fastly compute pack --wasm-binary artifacts/generated/fastly/pulsewasm-compute.wasm
+\`\`\`
+
+## Candidate local serve command
+
+\`\`\`bash
+fastly compute serve
+\`\`\`
+
+This package runs a mock Fastly hostcall adapter smoke in Node. It does not claim a real \`fastly compute serve\` run unless the external reality task executes through the Fastly CLI.
+`;
+}
+
+function buildStreamHeaderAdapterArtifact({ generatedBy, smoke, packagingSmoke, compiledWasmRuntime, fastlyHostcallBinding }) {
+  const checks = smoke ? smoke.summary.checks : 0;
+  const failed = smoke ? smoke.summary.failedChecks : 0;
+  return {
+    version: FASTLY_STREAM_HEADER_ADAPTER_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: failed === 0 ? 'ok' : 'error',
+    posture: {
+      adapterProof: true,
+      realFastlyHostcalls: false,
+      mockHostcallSurface: true,
+      sdkDependency: false,
+      sdkReferenceOnly: true,
+      deploymentPackageGenerated: Boolean(packagingSmoke && packagingSmoke.summary && packagingSmoke.summary.packageGenerated),
+      fastlyCliRequiredForPackServe: true,
+      fastlyCliAvailable: Boolean(packagingSmoke && packagingSmoke.fastlyCli && packagingSmoke.fastlyCli.available),
+      localFastlyServeExecuted: Boolean(packagingSmoke && packagingSmoke.summary && packagingSmoke.summary.serveExecuted)
+    },
+    maps: {
+      incomingRequest: 'Fastly-like request handle -> PulseWasm HostRequest',
+      headers: 'ordered repeated headers -> Pulse header bag -> ordered repeated response headers',
+      resultStream: 'Pulse RESULT_STREAM / responseRef -> Fastly-like response/body stream',
+      body: 'host-owned stream bytes; no copy into Wasm',
+      runtime: 'compiled-wasm host runtime; no pulsewasm_handlers JS imports'
+    },
+    linkedInputs: {
+      compiledWasmRuntime: compiledWasmRuntime?.artifact?.version,
+      fastlyHostcallBinding: fastlyHostcallBinding?.artifact?.version
+    },
+    summary: {
+      checks,
+      failedChecks: failed,
+      mockFastlyAdapter: true,
+      streamHeaderProof: failed === 0,
+      fastlyCliAvailable: Boolean(packagingSmoke && packagingSmoke.fastlyCli && packagingSmoke.fastlyCli.available),
+      packCommandReady: true,
+      serveCommandReady: true
+    }
+  };
+}
+
+function buildPackagingSmoke({ cwd, outDir, wasmSource, generatedBy }) {
+  const fastlyVersion = spawnSync('fastly', ['--version'], { cwd, encoding: 'utf8', timeout: 10_000 });
+  const fastlyAvailable = !fastlyVersion.error && fastlyVersion.status === 0;
+  const targetDir = path.join(outDir, 'generated', 'fastly');
+  fs.mkdirSync(targetDir, { recursive: true });
+  const wasmTarget = path.join(targetDir, 'pulsewasm-compute.wasm');
+  let copied = false;
+  let copiedRecord;
+  if (wasmSource && fs.existsSync(wasmSource)) {
+    fs.copyFileSync(wasmSource, wasmTarget);
+    copied = true;
+    copiedRecord = fileRecord(wasmTarget, cwd, 'fastly-compute-wasm-candidate');
+  }
+  const packCommand = 'fastly compute pack --wasm-binary artifacts/generated/fastly/pulsewasm-compute.wasm';
+  return {
+    version: FASTLY_PACKAGING_SMOKE_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: 'ok',
+    fastlyCli: {
+      available: fastlyAvailable,
+      versionOutput: fastlyAvailable ? String(fastlyVersion.stdout || fastlyVersion.stderr || '').trim() : undefined,
+      error: fastlyAvailable ? undefined : (fastlyVersion.error ? fastlyVersion.error.message : `exit ${fastlyVersion.status}`)
+    },
+    commands: {
+      pack: packCommand,
+      serve: 'fastly compute serve',
+      deploy: 'fastly compute deploy'
+    },
+    packageCandidate: {
+      wasmCopied: copied,
+      wasm: copiedRecord,
+      fastlyToml: 'generated/fastly/fastly.toml',
+      readme: 'generated/fastly/README.md'
+    },
+    execution: {
+      packExecuted: false,
+      serveExecuted: false,
+      deployExecuted: false,
+      reason: fastlyAvailable
+        ? 'Fastly CLI is available, but this artifact does not execute pack/serve automatically; use the external reality task.'
+        : 'The Fastly CLI local Compute lifecycle was not available in this environment, so the generator emitted a pack-ready scaffold and ran the mock adapter smoke only.'
+    },
+    summary: {
+      fastlyCliAvailable: fastlyAvailable,
+      wasmCopied: copied,
+      packageGenerated: false,
+      packExecuted: false,
+      serveExecuted: false,
+      deployExecuted: false
+    }
+  };
+}
+
+function loadModuleFromText(text, filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, text, 'utf8');
+  delete require.cache[filePath];
+  return require(filePath);
+}
+
+function runFastlyLocalSmoke({ compiledWasmRuntime, adapterSource, wasmFile, cwd }) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pulsewasm-fastly-adapter-'));
+  const hostFile = findFile(compiledWasmRuntime?.files, 'generated/host/compiled-wasm-host-runtime.cjs');
+  if (!hostFile) throw new Error('compiled-wasm-host-runtime.cjs was not available from the compiled-wasm runtime output.');
+  const hostModule = loadModuleFromText(hostFile.text, path.join(tempDir, 'compiled-wasm-host-runtime.cjs'));
+  const adapterModule = loadModuleFromText(adapterSource, path.join(tempDir, 'fastly-adapter.cjs'));
+
+  const runtime = hostModule.createPulseWasmCompiledHostRuntime({
+    wasmPath: wasmFile,
+    deploymentPosture: { engine: 'wasm', wasmOptimized: true },
+    hostResponses: {
+      77: {
+        status: 206,
+        headers: [
+          ['Content-Type', 'application/octet-stream'],
+          ['Cache-Control', 'public, max-age=60'],
+          ['Grip-Channel', 'backend:stream'],
+          ['Server', 'origin']
+        ],
+        bodyStream: { kind: 'mock-fastly-body', chunks: ['asset:', '42'] }
+      }
+    }
+  });
+
+  const adapter = adapterModule.createFastlyStreamHeaderAdapter({ runtime });
+  const streamResponse = adapter.handleRequest({
+    method: 'GET',
+    path: '/stream',
+    rawHeaders: ['X-Trace', 'abc', 'Grip-Channel', 'client:a', 'Grip-Channel', 'client:b']
+  });
+  const schemaResponse = adapter.handleRequest({
+    method: 'POST',
+    path: '/users',
+    rawHeaders: ['Content-Type', 'application/json'],
+    bodyText: '{"name":"Ada","age":42,"active":true}'
+  });
+  const missingResponse = adapter.handleRequest({ method: 'GET', path: '/missing' });
+
+  function values(headers, name) {
+    return (headers || []).filter(([key]) => String(key).toLowerCase() === String(name).toLowerCase()).map(([, value]) => value);
+  }
+  const firstRequest = adapter.observed.requests[0];
+  const checks = [];
+  function check(name, expected, actual) {
+    checks.push({ name, expected, actual, status: Object.is(expected, actual) ? 'ok' : 'error', message: Object.is(expected, actual) ? undefined : `Expected ${expected}, got ${actual}.` });
+  }
+  check('fastly_request_path_mapped', '/stream', firstRequest.path);
+  check('fastly_request_method_mapped', 'GET', firstRequest.method);
+  check('fastly_repeated_request_headers_preserved', 2, values(firstRequest.headers, 'Grip-Channel').length);
+  check('stream_status', 206, streamResponse.status);
+  check('stream_kind', 'stream', streamResponse.kind);
+  check('stream_body_forwarded', 'asset:42', streamResponse.body);
+  check('stream_response_ref_visible', 77, streamResponse.responseRef);
+  check('backend_content_type_preserved', 'application/octet-stream', values(streamResponse.headers, 'Content-Type')[0]);
+  check('cache_control_overridden', 'public, max-age=120', values(streamResponse.headers, 'Cache-Control')[0]);
+  check('backend_server_header_preserved_without_delete', 1, values(streamResponse.headers, 'Server').length);
+  check('grip_channel_repeated_preserved', 2, values(streamResponse.headers, 'Grip-Channel').length);
+  check('schema_status', 201, schemaResponse.status);
+  check('schema_kind', 'json', schemaResponse.kind);
+  check('schema_body', '{"name":"Ada","age":42,"active":true}', schemaResponse.body);
+  check('missing_status', 404, missingResponse.status);
+  check('no_js_handler_imports', 0, runtime.imports.filter((item) => item.module === 'pulsewasm_handlers').length);
+  return {
+    version: FASTLY_LOCAL_SMOKE_VERSION,
+    generatedBy: PACKAGE_VERSION,
+    phase: PHASE,
+    status: checks.every((item) => item.status === 'ok') ? 'ok' : 'error',
+    checks,
+    failedChecks: checks.filter((item) => item.status !== 'ok'),
+    observed: {
+      requests: adapter.observed.requests,
+      streamResponse,
+      schemaResponse,
+      missingResponse
+    },
+    summary: {
+      executed: true,
+      checks: checks.length,
+      failedChecks: checks.filter((item) => item.status !== 'ok').length,
+      streamHeaderProof: true,
+      compiledWasmRuntimeDriven: true,
+      nodeAdapterUsed: false,
+      fastlyCliRequired: false,
+      realFastlyHostcalls: false,
+      mockHostcallSurface: true
+    }
+  };
+}
+
+function buildDeploymentReadiness({ generatedBy, localSmoke, packagingSmoke }) {
+  const localOk = Boolean(localSmoke && localSmoke.summary && localSmoke.summary.failedChecks === 0);
+  return {
+    version: FASTLY_DEPLOYMENT_READINESS_VERSION,
+    generatedBy,
+    phase: PHASE,
+    readiness: {
+      mockAdapterSmokeReady: localOk,
+      packageScaffoldReady: Boolean(packagingSmoke && packagingSmoke.summary && packagingSmoke.summary.wasmCopied),
+      localFastlyServeReady: Boolean(packagingSmoke && packagingSmoke.fastlyCli && packagingSmoke.fastlyCli.available),
+      remoteDeployReady: false,
+      deployRequiresAccountServiceToken: true
+    },
+    nextManualSteps: [
+      'Install the Fastly CLI and ensure `fastly compute serve` can run its managed local Compute engine.',
+      'Run `fastly compute pack --wasm-binary artifacts/generated/fastly/pulsewasm-compute.wasm` from the PulseWasm root.',
+      'Run `fastly compute serve` for local Fastly tooling validation.',
+      'Use `fastly compute deploy` only after service/account/token setup.'
+    ],
+    verdict: localOk
+      ? 'The stream/header adapter shape is validated through a mock Fastly hostcall surface and a pack-ready scaffold. Real Fastly serve/deploy remains an explicit environment step.'
+      : 'The local adapter smoke failed; inspect fastly-local-smoke.json.',
+    summary: {
+      readyForManualPack: Boolean(packagingSmoke && packagingSmoke.summary && packagingSmoke.summary.wasmCopied),
+      readyForManualServeIfCliInstalled: localOk,
+      readyForRemoteDeploy: false
+    }
+  };
+}
+
+function buildMarkdown(artifact) {
+  const lines = [
+    '# PulseWasm Fastly Stream/Header Adapter Proof',
+    '',
+    '## Status',
+    artifact.status === 'ok' ? 'Implemented.' : 'Generated with errors.',
+    '',
+    '## Boundary',
+    '',
+    '- SDKs are references, not dependencies.',
+    '- This proof uses a mock Fastly hostcall surface in Node.',
+    '- Fastly CLI pack/serve is recorded as a scaffold step, not silently claimed.',
+    '- No backend fetch effect, Fanout/GRIP, or real asset adapter is implemented.',
+    '',
+    '## Summary',
+    '',
+    `- Local smoke checks: ${artifact.summary.checks}`,
+    `- Failed checks: ${artifact.summary.failedChecks}`,
+    `- Fastly CLI available: ${artifact.summary.fastlyCliAvailable}`,
+    `- Pack-ready scaffold emitted: ${artifact.summary.packReady}`,
+    ''
+  ];
+  return `${lines.join('\n')}\n`;
+}
+
+function buildFastlyStreamHeaderAdapter({ compiledWasmRuntime, fastlyHostcallBinding, fastlyReadiness, streamingPassthrough, wasmHostAbi } = {}, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const outDir = options.outDir || getDefaultArtifactsDir(cwd);
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const diagnostics = [];
+  if (!compiledWasmRuntime || !compiledWasmRuntime.artifact) diagnostics.push(diag('PULSEWASM_FASTLY_COMPILED_RUNTIME_REQUIRED', 'The Fastly adapter requires compiled-wasm-runtime.json.', 'Enable --emit-compiled-wasm-runtime.'));
+  if (!fastlyHostcallBinding || !fastlyHostcallBinding.artifact) diagnostics.push(diag('PULSEWASM_FASTLY_HOSTCALL_CONTRACT_REQUIRED', 'The Fastly adapter requires the Fastly hostcall binding contract.', 'Enable --emit-fastly-hostcall-binding.'));
+  const wasmOutput = findOutputFile(compiledWasmRuntime?.outputFiles, 'pulsewasm-compiled-runtime.wasm');
+  const wasmFile = wasmOutput ? path.resolve(cwd, wasmOutput.file) : path.join(outDir, 'generated/compiled-wasm-runtime/pulsewasm-compiled-runtime.wasm');
+  if (!fs.existsSync(wasmFile)) diagnostics.push(diag('PULSEWASM_FASTLY_COMPILED_WASM_MISSING', 'The Fastly adapter expected the compiled runtime Wasm to exist.', 'Run --emit-compiled-wasm-runtime before Fastly adapter proof.', { wasmFile }));
+
+  const adapterSource = buildFastlyAdapterSource();
+  const files = [
+    makeFile('generated/fastly/fastly-adapter.cjs', adapterSource),
+    makeFile('generated/fastly/fastly.toml', buildFastlyToml()),
+    makeFile('generated/fastly/README.md', buildFastlyReadme())
+  ];
+  let packagingSmoke = buildPackagingSmoke({ cwd, outDir, wasmSource: fs.existsSync(wasmFile) ? wasmFile : undefined, generatedBy });
+  const outputFiles = [];
+  if (packagingSmoke.packageCandidate.wasm && packagingSmoke.packageCandidate.wasm.file) {
+    outputFiles.push(packagingSmoke.packageCandidate.wasm);
+  }
+  let localSmoke;
+  if (diagnostics.length === 0) {
+    try {
+      localSmoke = runFastlyLocalSmoke({ compiledWasmRuntime, adapterSource, wasmFile, cwd });
+      if (localSmoke.failedChecks.length > 0) diagnostics.push(diag('PULSEWASM_FASTLY_LOCAL_SMOKE_FAILED', 'Fastly stream/header adapter smoke failed.', 'Inspect fastly-local-smoke.json.', { failedChecks: localSmoke.failedChecks }));
+    } catch (error) {
+      diagnostics.push(diag('PULSEWASM_FASTLY_LOCAL_SMOKE_EXECUTION_FAILED', 'Fastly stream/header adapter smoke could not execute.', 'Inspect the generated adapter and compiled runtime artifacts.', { message: error && error.message ? error.message : String(error), stack: error && error.stack ? error.stack : undefined }));
+    }
+  }
+  if (!localSmoke) {
+    localSmoke = {
+      version: FASTLY_LOCAL_SMOKE_VERSION,
+      generatedBy,
+      phase: PHASE,
+      status: 'not-run',
+      checks: [],
+      failedChecks: [],
+      summary: { executed: false, checks: 0, failedChecks: 0, streamHeaderProof: false }
+    };
+  }
+  const streamHeaderAdapter = buildStreamHeaderAdapterArtifact({ generatedBy, smoke: localSmoke, packagingSmoke, compiledWasmRuntime, fastlyHostcallBinding });
+  const deploymentReadiness = buildDeploymentReadiness({ generatedBy, localSmoke, packagingSmoke });
+  const artifact = normalizeArtifact({
+    version: FASTLY_ADAPTER_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: diagnostics.filter((item) => item.severity !== 'warning').length === 0 ? 'ok' : 'error',
+    posture: {
+      adapterImplemented: true,
+      streamHeaderProof: true,
+      realFastlyHostcalls: false,
+      mockHostcallSurface: true,
+      sdkDependency: false,
+      officialSdkWrapper: false,
+      customHostcallPath: true,
+      packagingScaffoldGenerated: true,
+      fastlyPackExecuted: false,
+      fastlyServeExecuted: false,
+      remoteDeployExecuted: false
+    },
+    scope: [
+      'Fastly-like request method/path/header normalization',
+      'compiled-wasm runtime execution',
+      'RESULT_STREAM / responseRef translation',
+      'ordered repeated response header preservation',
+      'pack-ready scaffold generation'
+    ],
+    reserved: [
+      'real Fastly hostcall implementation',
+      'fastly compute serve execution',
+      'remote deploy',
+      'backend fetch effect runtime',
+      'Fanout / GRIP',
+      'real pulse.assets',
+      'WIT generation'
+    ],
+    linkedArtifacts: {
+      compiledWasmRuntime: compiledWasmRuntime?.artifact?.version,
+      fastlyHostcallBinding: fastlyHostcallBinding?.artifact?.version,
+      fastlyReadiness: fastlyReadiness?.artifact?.version,
+      wasmHostAbi: wasmHostAbi?.artifact?.version,
+      streamingPassthrough: streamingPassthrough?.artifact?.version
+    },
+    summary: {
+      checks: localSmoke.summary.checks,
+      failedChecks: localSmoke.summary.failedChecks,
+      adapterImplemented: true,
+      localMockSmokeExecuted: Boolean(localSmoke.summary.executed),
+      streamHeaderProof: localSmoke.summary.failedChecks === 0 && Boolean(localSmoke.summary.executed),
+      fastlyCliAvailable: Boolean(packagingSmoke.fastlyCli.available),
+      packReady: Boolean(packagingSmoke.summary.wasmCopied),
+      packExecuted: false,
+      serveExecuted: false,
+      deployExecuted: false,
+      diagnostics: diagnostics.length
+    }
+  }, cwd);
+  files.push(makeFile('generated/host/fastly-stream-header-adapter.md', buildMarkdown(artifact)));
+  return {
+    artifact,
+    streamHeaderAdapter: normalizeArtifact(streamHeaderAdapter, cwd),
+    localSmoke: normalizeArtifact(localSmoke, cwd),
+    packagingSmoke: normalizeArtifact(packagingSmoke, cwd),
+    deploymentReadiness: normalizeArtifact(deploymentReadiness, cwd),
+    files,
+    outputFiles,
+    diagnostics
+  };
+}
+
+module.exports = { buildFastlyStreamHeaderAdapter };