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

package/README.md

@@ -1,3 +1,54 @@
 # @pulse-compute/wasm-compiler
 
-This is an inert namespace-bootstrap package. It contains no executable code.
+<!-- pulse-package-status:start -->
+> **Support tier:** Implementation/transitive surface<br>
+> **Audience:** Pulse compiler and release maintainers.<br>
+> **Install directly:** No for application projects; use the pulse CLI.<br>
+> **Supported entry points:** `None for application authors.`<br>
+> **Stability:** Internal compiler interface; no application-author compatibility guarantee.<br>
+> **Canonical replacement:** `@pulse-compute/cli`<br>
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.1/packages/implementation-packages/)
+>
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.1` package policy.
+<!-- pulse-package-status:end -->
+
+Whole-project compiler implementation used by the `pulse` workflow. Application projects should use `@pulse-compute/cli`, not import this package directly.
+
+## Responsibilities
+
+- resolve and validate compiler inputs;
+- compile canonical handler source into values, effects, continuations, and capability metadata;
+- compile explicitly declared JSON schemas through the schema package;
+- discover trusted package-owned manifests and invoke their owning builders;
+- merge package effects with canonical operations;
+- emit versioned canonical plans and build artifacts;
+- expose implementation diagnostics to the product workflow.
+
+## Boundaries
+
+The compiler orchestrates contracts but does not own:
+
+- product command parsing or project UX;
+- provider execution;
+- provider SDK behavior;
+- package-specific AST rules for GRIP or assets;
+- schema payload semantics;
+- application runtime authority.
+
+Package-specific lowering belongs to the package owning the facade. Provider realization belongs to provider packages. Shared protocol vocabulary belongs to `@pulse-compute/wasm-contracts`.
+
+## Internal compiler spine
+
+The compiler connects root extraction, surface recognition, normalization, classification, validation, canonical IR, native lowering, provider realization, and artifact verification through a fixed package-internal pipeline. The pipeline is not exported and is not a plugin framework. Compiler refactors must preserve checked-in metadata, diagnostics, native-plan, and generated-Wasm evidence unless an explicit contract migration authorizes a difference.
+
+The canonical-source and Router frontends now share package-internal handler-surface recognition and compatibility diagnostic authorities. The shared surface authority consumes the contracts package vocabulary, retains frontend-specific syntax compatibility, records facts without changing compiler outputs, and does not enable async or widen source support by itself. Canonical IR generation remains behind legacy compatibility envelopes until the dedicated frontend migration phases.
+
+## Exported implementation modules
+
+The package exports its root implementation plus focused compiler, CLI, extractor, config resolver, diagnostics, build-manifest, canonical API compiler, and canonical project compiler modules. These are synchronized internal interfaces without an application-author compatibility guarantee.
+
+## Validation
+
+Compiler changes should be covered by focused static/lowering tests, canonical project inspection, provider-plan parity, packed-package discovery where relevant, and the release documentation gates.
+
+See the installed [implementation package guide](https://pulsecompute.io/v1.0.0-beta.1/packages/implementation-packages/) and [compilation concepts](https://pulsecompute.io/v1.0.0-beta.1/concepts/compilation-and-lowering/).

package/bin/provider-proof-composition.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const node = require('@pulse-compute/provider-node/compiler');
+const fastly = require('@pulse-compute/provider-fastly/compiler');
+const {
+  buildNodeLiveOriginRouteHandlerEffectProof
+} = require('@pulse-compute/provider-node/compiler/route-handler-live-origin-proof');
+const {
+  buildNodeCompiledRouteHandlerEffectBridge
+} = require('@pulse-compute/provider-node/compiler/route-handler-compiled-wasm-bridge');
+const {
+  buildNodeBackendJsonRequestBodyProof
+} = require('@pulse-compute/provider-node/compiler/backend-json-request-body-proof');
+
+module.exports = Object.freeze({
+  buildNodeAdapter: node.buildNodeAdapter,
+  buildNodeAssetsProviderProof: node.buildNodeAssetsProviderProof,
+  buildNodeCompiledWasmAssetsLifecycleProof: node.buildNodeCompiledWasmAssetsLifecycleProof,
+  buildNodeRouteHandlerEffectProof: node.buildNodeRouteHandlerEffectProof,
+  buildNodeRequestJsonBodyProof: node.buildNodeRequestJsonBodyProof,
+  buildNodeSchemaDecodeResultProof: node.buildNodeSchemaDecodeResultProof,
+  buildNodeSchemaResponseCodecProof: node.buildNodeSchemaResponseCodecProof,
+  buildNodeLiveOriginRouteHandlerEffectProof,
+  buildNodeCompiledRouteHandlerEffectBridge,
+  buildNodeBackendJsonRequestBodyProof,
+  buildFastlyReadiness: fastly.buildFastlyReadiness,
+  buildFastlyHostcallBinding: fastly.buildFastlyHostcallBinding,
+  buildFastlyStreamHeaderAdapter: fastly.buildFastlyStreamHeaderAdapter,
+  buildFastlyCommandEntry: fastly.buildFastlyCommandEntry,
+  buildFastlyAssetsProviderProof: fastly.buildFastlyAssetsProviderProof,
+  buildFastlyAssetsPackageOutParityProof: fastly.buildFastlyAssetsPackageOutParityProof,
+  buildFastlyRouteHandlerEffectProof: fastly.buildFastlyRouteHandlerEffectProof,
+  buildFastlyLifecycleParityProof: fastly.buildFastlyLifecycleParityProof
+});

package/bin/pulsewasm-extract.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+
+const { runCli } = require('../src/cli.js');
+const { getDefaultArtifactsDir } = require('@pulse-compute/wasm-build-support/artifacts-dir');
+const providerProofs = require('./provider-proof-composition.js');
+
+runCli(process.argv.slice(2), {
+  cwd: process.cwd(),
+  stdout: process.stdout,
+  stderr: process.stderr,
+  defaultOutDir: getDefaultArtifactsDir(process.cwd()),
+  providerProofs,
+  exitOnComplete: true
+}).then(() => {
+  process.exit(process.exitCode || 0);
+}).catch((error) => {
+  process.stderr.write(`${error && error.stack ? error.stack : String(error)}\n`);
+  process.exit(1);
+});

package/package.json

@@ -1,15 +1,70 @@
 {
   "name": "@pulse-compute/wasm-compiler",
-  "version": "0.0.0",
-  "description": "Inert namespace bootstrap for Pulse.",
+  "version": "1.0.0-beta.1",
   "license": "Apache-2.0",
+  "description": "PulseWasm compiler package inside the Pulse monorepo.",
+  "type": "commonjs",
+  "bin": {
+    "pulsewasm-extract": "./bin/pulsewasm-extract.js",
+    "pulsewasm": "./bin/pulsewasm-extract.js"
+  },
+  "dependencies": {
+    "@pulse-compute/provider-fastly": "1.0.0-beta.1",
+    "@pulse-compute/provider-node": "1.0.0-beta.1",
+    "@pulse-compute/wasm-build-support": "1.0.0-beta.1",
+    "@pulse-compute/wasm-contracts": "1.0.0-beta.1",
+    "@pulse-compute/wasm-guest-link": "1.0.0-beta.1",
+    "@pulse-compute/wasm-host-runtime": "1.0.0-beta.1",
+    "@pulse-compute/wasm-library-kit": "1.0.0-beta.1",
+    "@pulse-compute/wasm-runtime-core-as": "1.0.0-beta.1",
+    "@pulse-compute/wasm-schema-json": "1.0.0-beta.1",
+    "assemblyscript": "0.28.18",
+    "json-as": "1.5.0",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "node": "^22.14.0 || ^24.0.0"
+  },
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./cli": "./src/cli.js",
+    "./extractor": "./src/extractor.js",
+    "./config-resolver": "./src/config-resolver.js",
+    "./diagnostics": "./src/diagnostics.js",
+    "./build-manifest": "./src/build-manifest.js",
+    "./canonical-api-compiler": "./src/canonical-api-compiler.js",
+    "./canonical-native-plan": "./src/canonical-native-plan.js",
+    "./canonical-native-compiler": "./src/canonical-native-compiler.js",
+    "./canonical-project-compiler": "./src/canonical-project-compiler.js",
+    "./project-config-compiler": "./src/project-config-compiler.js",
+    "./crypto-requirement-planner": "./src/crypto-requirement-planner.js",
+    "./javascript-application-plan": "./src/javascript-application-plan.js",
+    "./provider-toolchain": "./src/provider-toolchain.js",
+    "./project-target-support": "./src/project-target-support.js"
+  },
   "files": [
+    "bin",
+    "src",
     "README.md",
     "LICENSE",
     "NOTICE"
   ],
   "publishConfig": {
-    "access": "public",
-    "tag": "bootstrap"
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pulse-compute/pulse.git",
+    "directory": "wasm/packages/compiler"
+  },
+  "homepage": "https://pulsecompute.io/v1.0.0-beta.1/packages/implementation-packages/",
+  "bugs": {
+    "url": "https://github.com/pulse-compute/pulse/issues"
+  },
+  "scripts": {
+    "build": "node ./bin/pulsewasm-extract.js build --config ./examples/pulse.config.js --profile edge --env ASSET_ENDPOINT=https://assets.example.test --env ASSET_BUCKET=pulse-assets --env USERS_API_BASE_URL=https://users.example.test --out ../../artifacts --emit-ast",
+    "extract": "node ./bin/pulsewasm-extract.js build ./examples/example.js --root app --out ../../artifacts --emit-ast",
+    "test": "node ../../scripts/run-wasm-tests.cjs --profile native --no-report"
   }
-}
+}

package/src/artifacts-dir.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const path = require('node:path');
+const support = require('@pulse-compute/wasm-build-support/artifacts-dir');
+
+function getCompilerPackageRoot() {
+  return path.resolve(__dirname, '..');
+}
+
+module.exports = {
+  ...support,
+  getCompilerPackageRoot
+};

package/src/ast-json.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { sourceLoc } = require('./diagnostics.js');
+
+const TEXT_KINDS = new Set([
+  'Identifier',
+  'StringLiteral',
+  'NoSubstitutionTemplateLiteral',
+  'NumericLiteral',
+  'PropertyAccessExpression',
+  'CallExpression',
+  'NewExpression',
+  'VariableDeclaration',
+  'FunctionDeclaration',
+  'ArrowFunction',
+  'FunctionExpression'
+]);
+
+function compactText(text, maxLength) {
+  const value = text.replace(/\s+/g, ' ').trim();
+  return value.length > maxLength ? `${value.slice(0, maxLength)}…` : value;
+}
+
+function astToJson(ts, sourceFile, options = {}) {
+  const maxTextLength = options.maxTextLength ?? 180;
+  const maxDepth = options.maxDepth ?? 80;
+
+  function visit(node, depth) {
+    const kind = ts.SyntaxKind[node.kind] || String(node.kind);
+    const out = {
+      kind,
+      loc: sourceLoc(sourceFile, node)
+    };
+    if (TEXT_KINDS.has(kind)) {
+      out.text = compactText(node.getText(sourceFile), maxTextLength);
+    }
+    if (depth >= maxDepth) {
+      out.truncated = true;
+      return out;
+    }
+    const children = [];
+    ts.forEachChild(node, (child) => {
+      children.push(visit(child, depth + 1));
+    });
+    if (children.length > 0) out.children = children;
+    return out;
+  }
+
+  return visit(sourceFile, 0);
+}
+
+module.exports = { astToJson };

package/src/build-manifest.js

@@ -0,0 +1,354 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const path = require('node:path');
+const { PACKAGE_VERSION, countDiagnostics, normalizeArtifact, stableFileName } = require('./diagnostics.js');
+const { getDefaultArtifactsDir } = require('@pulse-compute/wasm-build-support/artifacts-dir');
+
+const ARTIFACT_ORDER = [
+  'resolved-config.json',
+  'cli-doctor.json',
+  'symbol-index.json',
+  'handler-table.json',
+  'handler-eval.json',
+  'path-table.json',
+  'dispatch-table.json',
+  'execution-plan.json',
+  'handler-bindings.json',
+  'execution-harness.json',
+  'local-harness.json',
+  'assemblyscript-shape.json',
+  'assemblyscript-core.json',
+  'assemblyscript-handlers.json',
+  'assemblyscript-compile.json',
+  'assemblyscript-wasm-smoke.json',
+  'wasm-host-abi.json',
+  'wasm-host-bridge.json',
+  'request-result-headers.json',
+  'channel-broadcaster.json',
+  'json-body.json',
+  'backend-capabilities.json',
+  'deployment-posture.json',
+  'host-runtime-kernel.json',
+  'node-adapter.json',
+  'handler-library-contracts.json',
+  'handler-execution-modes.json',
+  'library-contract-schema.json',
+  'library-capabilities.json',
+  'library-compatibility-report.json',
+  'assets-lowering-plan.json',
+  'assets-compiled-wasm-sidecar-plan.json',
+  'assets-sidecar-compile-link-proof.json',
+  'assets-package-owned-lowering-proof.json',
+  'assets-package-out-discovery-proof.json',
+  'grip-lowering-plan.json',
+  'second-package-owned-lowering-proof.json',
+  'grip-package-owned-lowering-proof.json',
+  'guest-unit-plan.json',
+  'guest-link-report.json',
+  'final-wasm-audit.json',
+  'node-assets-provider-proof.json',
+  'node-compiled-wasm-assets-lifecycle-proof.json',
+  'fastly-assets-provider-proof.json',
+  'fastly-assets-package-out-parity-proof.json',
+  'route-handler-effect-plan.json',
+  'node-route-handler-effect-proof.json',
+  'node-live-origin-route-handler-effect-proof.json',
+  'node-compiled-route-handler-effect-bridge.json',
+  'fastly-route-handler-effect-proof.json',
+  'fastly-lifecycle-parity-proof.json',
+  'route-handler-context-lowering-plan.json',
+  'handler-io-lifecycle-plan.json',
+  'request-json-body-plan.json',
+  'node-request-json-body-proof.json',
+  'schema-decode-result-plan.json',
+  'node-schema-decode-result-proof.json',
+  'schema-response-codec-plan.json',
+  'backend-json-request-body-plan.json',
+  'node-backend-json-request-body-proof.json',
+  'node-schema-response-codec-proof.json',
+  'reference-lifecycle-stabilization-proof.json',
+  'reference-node-lifecycle-golden.json',
+  'beta-lifecycle-golden.json',
+  'lifecycle-authoring-alignment.json',
+  'lifecycle-readiness-aggregate.json',
+  'doctor-readiness-aggregator.json',
+  'host-capabilities.json',
+  'host-capability-contract.json',
+  'wasi-provider-map.json',
+  'capability-provider-report.json',
+  'effect-runtime.json',
+  'effect-runtime-contract.json',
+  'effect-kind-registry.json',
+  'effect-resume-protocol.json',
+  'effect-timeout-policy.json',
+  'effect-composition.json',
+  'effect-plan-contract.json',
+  'effect-continuation-contract.json',
+  'timeout-scope-policy.json',
+  'compiled-handler-plan.json',
+  'handler-lowering-report.json',
+  'compiled-handler-hardening.json',
+  'compiled-handler-smoke.json',
+  'wrapper-integration.json',
+  'pulse-build-output.json',
+  'pulse-dev-runtime.json',
+  'schema-json-generic-parser.json',
+  'schema-json-generic-parser-plan.json',
+  'schema-json-generic-parser-abi.json',
+  'schema-json-generic-parser-smoke.json',
+  'schema-json-sidecar.json',
+  'schema-json-plan.json',
+  'schema-json-parser-report.json',
+  'schema-json-registry.json',
+  'schema-json-sidecar-abi.json',
+  'schema-json-body-policy.json',
+  'schema-json-smoke.json',
+  'generated/as/schema-json/generic/as-json-parser.as.ts',
+  'generated/as-smoke/schema-json-generic-parser-smoke-runner.as.ts',
+  'generated/schema-json-generic-parser/pulsewasm-schema-json-generic-parser.wasm',
+  'generated/schema-json-generic-parser/pulsewasm-schema-json-generic-parser.wat',
+  'generated/host/schema-json-generic-parser.md',
+  'generated/host/handler-library-contracts.md',
+  'generated/host/host-capabilities.md',
+  'generated/host/effect-runtime.md',
+  'generated/host/effect-composition.md',
+  'generated/as/user-handlers.as.ts',
+  'generated/as-smoke/compiled-handler-smoke-runner.as.ts',
+  'generated/compiled-handlers/pulsewasm-compiled-handlers.wasm',
+  'generated/compiled-handlers/pulsewasm-compiled-handlers.wat',
+  'generated/as-smoke/pulsewasm-smoke.wasm',
+  'generated/as-smoke/pulsewasm-smoke.wat',
+  'generated/wasm-smoke/pulsewasm-local-smoke.wasm',
+  'generated/wasm-smoke/pulsewasm-local-smoke.wat',
+  'generated/as-smoke/smoke-runner.as.ts',
+  'generated/host/wasm-host-abi.md',
+  'generated/host/request-result-headers.md',
+  'generated/host/channel-broadcaster.md',
+  'generated/host/json-body.md',
+  'generated/host/backend-capabilities.md',
+  'generated/host/pulse-wrapper-integration.md',
+  'generated/pulse/pulse-wrapper.cjs',
+  'generated/host/host-runtime-kernel.cjs',
+  'generated/node/node-adapter.cjs',
+  'generated/host-bridge/host-bridge-runner.as.ts',
+  'generated/wasm-bridge/pulsewasm-host-bridge.wasm',
+  'generated/wasm-bridge/pulsewasm-host-bridge.wat',
+  'generated/manifest.json',
+  'generated/types.ts',
+  'generated/route-table.ts',
+  'generated/dispatch.ts',
+  'generated/handler-slots.ts',
+  'generated/execution-plan.ts',
+  'generated/execution-harness.ts',
+  'generated/local-harness.ts',
+  'generated/as/manifest.json',
+  'generated/as/types.as.ts',
+  'generated/as/route-table.as.ts',
+  'generated/as/dispatch-shape.as.ts',
+  'generated/as/runtime-path.as.ts',
+  'generated/as/handler-slots.as.ts',
+  'generated/as/runtime-core.as.ts',
+  'generated/as/index.as.ts',
+  'generated/index.ts',
+  'route-plan.json',
+  'route-id-map.json',
+  'router-ir.json',
+  'router-tree.json',
+  'diagnostics.json',
+  'ast.json',
+  'build-manifest.json'
+];
+
+function sha256(text) {
+  const hash = crypto.createHash('sha256');
+  if (Buffer.isBuffer(text)) hash.update(text);
+  else hash.update(String(text), 'utf8');
+  return hash.digest('hex');
+}
+
+function artifactVersion(value) {
+  return value && typeof value === 'object' && typeof value.version === 'string' ? value.version : undefined;
+}
+
+function artifactSortKey(fileName) {
+  const index = ARTIFACT_ORDER.indexOf(fileName);
+  return index === -1 ? ARTIFACT_ORDER.length + fileName.charCodeAt(0) : index;
+}
+
+function sortArtifacts(artifacts) {
+  return artifacts.slice().sort((a, b) => {
+    const ak = artifactSortKey(a.file);
+    const bk = artifactSortKey(b.file);
+    if (ak !== bk) return ak - bk;
+    return a.file.localeCompare(b.file);
+  });
+}
+
+function makeArtifactRecord(fileName, value, jsonText) {
+  return {
+    file: fileName,
+    version: artifactVersion(value),
+    bytes: Buffer.isBuffer(jsonText) ? jsonText.length : Buffer.byteLength(String(jsonText), 'utf8'),
+    sha256: sha256(jsonText)
+  };
+}
+
+function summarizeResult(result) {
+  if (!result) return undefined;
+  const routePlan = result.routePlan || {};
+  const handlerTable = result.handlerTable || {};
+  const handlerEval = result.handlerEval || {};
+  const dispatchTable = result.dispatchTable || {};
+  const dispatchTs = result.dispatchTs || {};
+  return {
+    routes: Array.isArray(routePlan.routes) ? routePlan.routes.length : 0,
+    handlers: Array.isArray(handlerTable.handlers) ? handlerTable.handlers.length : 0,
+    handlerEvalStatus: handlerEval.summary,
+    dispatch: dispatchTable.summary,
+    executionPlan: result.executionPlan?.summary,
+    handlerBindings: result.handlerBindings?.artifact?.summary,
+    executionHarness: result.executionHarness?.artifact?.summary,
+    localHarness: result.localHarness?.artifact?.summary,
+    assemblyScriptShape: result.assemblyScriptShape?.artifact?.summary,
+    assemblyScriptCore: result.assemblyScriptCore?.artifact?.summary,
+    assemblyScriptCompile: result.assemblyScriptCompile?.artifact?.summary,
+    assemblyScriptWasmSmoke: result.assemblyScriptWasmSmoke?.artifact?.summary,
+    wasmHostAbi: result.wasmHostAbi?.artifact?.summary,
+    wasmHostBridge: result.wasmHostBridge?.artifact?.summary,
+    requestResultHeaders: result.requestResultHeaders?.artifact?.summary,
+    channelBroadcaster: result.channelBroadcaster?.artifact?.summary,
+    jsonBody: result.jsonBody?.artifact?.summary,
+    backendCapabilities: result.backendCapabilities?.artifact?.summary,
+    deploymentPosture: result.deploymentPosture?.artifact?.summary,
+    hostRuntimeKernel: result.hostRuntimeKernel?.artifact?.summary,
+    nodeAdapter: result.nodeAdapter?.artifact?.summary,
+    handlerLibraryContracts: result.handlerLibraryContracts?.artifact?.summary,
+    doctorReadinessAggregator: result.doctorReadinessAggregator?.artifact?.summary,
+    lifecycleReadinessAggregate: result.lifecycleReadinessAggregate?.artifact?.summary,
+    assetsLoweringPlan: result.assetsLoweringPlan?.artifact?.summary,
+    nodeAssetsProviderProof: result.nodeAssetsProviderProof?.artifact?.summary,
+    fastlyAssetsProviderProof: result.fastlyAssetsProviderProof?.artifact?.summary,
+    fastlyAssetsPackageOutParityProof: result.fastlyAssetsPackageOutParityProof?.artifact?.summary,
+    routeHandlerEffectPlan: result.routeHandlerEffectPlan?.artifact?.summary,
+    nodeRouteHandlerEffectProof: result.nodeRouteHandlerEffectProof?.artifact?.summary,
+    nodeLiveOriginRouteHandlerEffectProof: result.nodeLiveOriginRouteHandlerEffectProof?.artifact?.summary,
+    nodeCompiledRouteHandlerEffectBridge: result.nodeCompiledRouteHandlerEffectBridge?.artifact?.summary,
+    fastlyRouteHandlerEffectProof: result.fastlyRouteHandlerEffectProof?.artifact?.summary,
+    fastlyLifecycleParityProof: result.fastlyLifecycleParityProof?.artifact?.summary,
+    routeHandlerContextLoweringPlan: result.routeHandlerContextLoweringPlan?.artifact?.summary,
+    handlerIoLifecyclePlan: result.handlerIoLifecyclePlan?.artifact?.summary,
+    requestJsonBodyPlan: result.requestJsonBodyPlan?.artifact?.summary,
+    schemaDecodeResultPlan: result.schemaDecodeResultPlan?.artifact?.summary,
+    schemaResponseCodecPlan: result.schemaResponseCodecPlan?.artifact?.summary,
+    backendJsonRequestBodyPlan: result.backendJsonRequestBodyPlan?.artifact?.summary,
+    nodeBackendJsonRequestBodyProof: result.nodeBackendJsonRequestBodyProof?.artifact?.summary,
+    nodeRequestJsonBodyProof: result.nodeRequestJsonBodyProof?.artifact?.summary,
+    nodeSchemaDecodeResultProof: result.nodeSchemaDecodeResultProof?.artifact?.summary,
+    nodeSchemaResponseCodecProof: result.nodeSchemaResponseCodecProof?.artifact?.summary,
+    hostCapabilities: result.hostCapabilities?.artifact?.summary,
+    effectRuntime: result.effectRuntime?.artifact?.summary,
+    effectComposition: result.effectComposition?.artifact?.summary,
+    compiledHandlers: result.compiledHandlers?.artifact?.summary,
+    schemaJsonCompile: result.schemaJsonCompile?.artifact?.summary,
+    schemaJsonGenericParser: result.schemaJsonGenericParser?.artifact?.summary,
+    schemaJsonSidecar: result.schemaJsonSidecar?.artifact?.summary,
+    dispatchTs: dispatchTs.manifest ? dispatchTs.manifest.summary : undefined
+  };
+}
+
+function createBuildManifest(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const outDir = options.outDir || getDefaultArtifactsDir(cwd);
+  const args = options.args || {};
+  const result = options.result;
+  const resolvedConfig = options.resolvedConfig;
+  const diagnostics = options.diagnostics || result?.diagnostics;
+  const status = options.status || diagnostics?.status || 'ok';
+  const artifactRecords = sortArtifacts(options.artifactRecords || []);
+
+  const entry = options.entry || args.entry || result?.summary?.entry || resolvedConfig?.entry;
+  const rootRouter = options.rootRouter || args.root || result?.summary?.rootRouter || resolvedConfig?.rootRouter;
+  const selectedProfile = resolvedConfig?.selectedProfile || args.profile;
+  const configSource = resolvedConfig?.artifact?.source || args.config;
+
+  return normalizeArtifact({
+    version: 'pulsewasm.build-manifest.v1',
+    generatedBy: PACKAGE_VERSION,
+    status,
+    command: args.command || 'build',
+    strict: args.strict !== false,
+    cwd: '.',
+    outDir: stableFileName(outDir, cwd),
+    config: configSource ? stableFileName(path.resolve(cwd, configSource), cwd) : undefined,
+    profile: selectedProfile,
+    entry: entry ? stableFileName(path.resolve(cwd, entry), cwd) : undefined,
+    rootRouter,
+    target: resolvedConfig?.target,
+    artifactCount: artifactRecords.length,
+    artifacts: artifactRecords,
+    artifactMap: artifactRecords.reduce((acc, artifact) => {
+      const key = artifact.file.replace(/\.json$/, '').replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
+      acc[key] = artifact.file;
+      return acc;
+    }, {}),
+    passes: diagnostics?.passes || result?.diagnostics?.passes || [],
+    diagnostics: diagnostics ? {
+      status: diagnostics.status,
+      counts: diagnostics.counts || countDiagnostics(diagnostics.diagnostics || [])
+    } : undefined,
+    summary: {
+      configOnly: Boolean(args.configOnly),
+      includeAst: Boolean(args.includeAst),
+      emitDispatchTs: Boolean(args.emitDispatchTs),
+      emitHandlerBindings: Boolean(args.emitHandlerBindings),
+      emitExecutionHarness: Boolean(args.emitExecutionHarness),
+      emitAssemblyScriptShape: Boolean(args.emitAssemblyScriptShape),
+      emitAssemblyScriptCore: Boolean(args.emitAssemblyScriptCore),
+      emitAssemblyScriptCompile: Boolean(args.emitAssemblyScriptCompile),
+      emitWasmSmoke: Boolean(args.emitWasmSmoke),
+      emitLocalHarness: Boolean(args.emitLocalHarness),
+      emitWasmHostAbi: Boolean(args.emitWasmHostAbi),
+      emitWasmHostBridge: Boolean(args.emitWasmHostBridge),
+      emitRequestResultHeaders: Boolean(args.emitRequestResultHeaders),
+      emitChannelBroadcaster: Boolean(args.emitChannelBroadcaster),
+      emitJsonBody: Boolean(args.emitJsonBody),
+      emitBackendCapabilities: Boolean(args.emitBackendCapabilities),
+      emitHostRuntimeKernel: Boolean(args.emitHostRuntimeKernel),
+      emitNodeAdapter: Boolean(args.emitNodeAdapter),
+      emitHandlerLibraryContracts: Boolean(args.emitHandlerLibraryContracts),
+      emitAssetsLoweringPlan: Boolean(args.emitAssetsLoweringPlan),
+      emitNodeAssetsProviderProof: Boolean(args.emitNodeAssetsProviderProof),
+      emitFastlyAssetsProviderProof: Boolean(args.emitFastlyAssetsProviderProof),
+      emitFastlyAssetsPackageOutParityProof: Boolean(args.emitFastlyAssetsPackageOutParityProof),
+      emitRouteHandlerEffectPlan: Boolean(args.emitRouteHandlerEffectPlan),
+      emitNodeRouteHandlerEffectProof: Boolean(args.emitNodeRouteHandlerEffectProof),
+      emitNodeLiveOriginRouteHandlerEffectProof: Boolean(args.emitNodeLiveOriginRouteHandlerEffectProof),
+      emitNodeCompiledRouteHandlerEffectBridge: Boolean(args.emitNodeCompiledRouteHandlerEffectBridge),
+      emitFastlyRouteHandlerEffectProof: Boolean(args.emitFastlyRouteHandlerEffectProof),
+      emitFastlyLifecycleParityProof: Boolean(args.emitFastlyLifecycleParityProof),
+      emitRouteHandlerContextLoweringPlan: Boolean(args.emitRouteHandlerContextLoweringPlan),
+      emitHandlerIoLifecyclePlan: Boolean(args.emitHandlerIoLifecyclePlan),
+      emitRequestJsonBodyPlan: Boolean(args.emitRequestJsonBodyPlan),
+      emitNodeRequestJsonBodyProof: Boolean(args.emitNodeRequestJsonBodyProof),
+      emitHostCapabilities: Boolean(args.emitHostCapabilities),
+      emitEffectRuntime: Boolean(args.emitEffectRuntime),
+      emitEffectComposition: Boolean(args.emitEffectComposition),
+      emitCompiledHandlers: Boolean(args.emitCompiledHandlers),
+      emitSchemaJsonCompile: Boolean(args.emitSchemaJsonCompile),
+      emitSchemaJsonGenericParser: Boolean(args.emitSchemaJsonGenericParser),
+      emitSchemaJsonSidecar: Boolean(args.emitSchemaJsonSidecar),
+      emitLibrarySidecars: Boolean(args.emitLibrarySidecars),
+      emitAssemblyScriptPathMatcher: Boolean(args.emitAssemblyScriptCore),
+      selectedProfile,
+      extraction: summarizeResult(result)
+    }
+  }, cwd);
+}
+
+module.exports = {
+  createBuildManifest,
+  makeArtifactRecord,
+  sha256,
+  sortArtifacts
+};