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

package/src/handler/doctor-readiness-aggregator.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const DOCTOR_READINESS_AGGREGATOR_VERSION = 'pulsewasm.doctor-readiness-aggregator.v1';
+const DOCTOR_READINESS_AGGREGATOR_PHASE = '53';
+const DOCTOR_READINESS_AGGREGATOR_ARTIFACT = 'doctor-readiness-aggregator.json';
+const DOCTOR_READINESS_AGGREGATOR_CONTRACT_ID = 'pulse.doctor-readiness-aggregator';
+
+const DOCTOR_READINESS_AGGREGATOR_SCOPE = Object.freeze({
+  betaApp: 'examples/beta-lifecycle/app.js',
+  referenceApp: 'examples/reference-node-lifecycle/app.js',
+  assetsPackageOutApp: 'examples/assets-package-out/app.js',
+  command: 'node wasm/scripts/run-wasm-tests.cjs --profile release --no-report',
+  cliDoctorReadinessRequired: true,
+  routeReadinessRequired: true,
+  packageReadinessRequired: true,
+  providerReadinessRequired: true,
+  planOnlyClassificationRequired: true,
+  splitProofClassificationRequired: true
+});
+
+const DOCTOR_READINESS_AGGREGATOR_POLICY = Object.freeze({
+  purpose: 'make pulsewasm doctor the developer-facing readiness aggregator for beta lifecycle routes, lowerable packages, providers, and plan-only edges',
+  productionCompletenessRequired: false,
+  betaQualityTarget: true,
+  simpleUserFunctionLoweringIntentional: true,
+  sourceOfTruth: Object.freeze({
+    routeShape: 'handler-io-lifecycle-plan.json and CLI doctor lifecycle section',
+    nodeBackendLifecycle: 'reference-node-lifecycle-golden.json and Node backend proof artifacts',
+    assetsPackageLifecycle: 'assets package-owned/package-out/sidecar and Node compiled-Wasm assets proof artifacts',
+    fastlyLifecycle: 'fastly-lifecycle-parity-proof.json and fastly-assets-package-out-parity-proof.json',
+    unsupportedEdges: 'contracts diagnostics plus lifecycle-authoring-alignment.json'
+  }),
+  readinessVocabulary: Object.freeze({
+    implemented: 'usable in the validated beta path',
+    implementedNarrow: 'usable for the documented narrow beta subset',
+    symbolicParity: 'provider-owned symbolic parity proof; no external service required',
+    planOnly: 'reserved/planned and diagnosed or classified, not silently implemented',
+    splitProofRequired: 'validated through split lifecycle proofs because the combined app is not yet lowered by one compiled bridge'
+  }),
+  requiredDoctorSections: Object.freeze([
+    'readiness.summary',
+    'readiness.routes',
+    'readiness.packages',
+    'readiness.providers',
+    'readiness.unsupportedEdges',
+    'readiness.actionableNextSteps'
+  ]),
+  outOfScope: Object.freeze([
+    'production asset CDN semantics',
+    'full Fastly compiled-Wasm runtime execution',
+    'single unified compiled bridge for backend and package-owned assets handlers in the combined beta app',
+    'arbitrary third-party compiler lowerer execution',
+    'async/await lowering',
+    'Promise lowering',
+    'automatic schema generation',
+    'arbitrary JavaScript object lowering'
+  ])
+});
+
+module.exports = {
+  DOCTOR_READINESS_AGGREGATOR_VERSION,
+  DOCTOR_READINESS_AGGREGATOR_PHASE,
+  DOCTOR_READINESS_AGGREGATOR_ARTIFACT,
+  DOCTOR_READINESS_AGGREGATOR_CONTRACT_ID,
+  DOCTOR_READINESS_AGGREGATOR_SCOPE,
+  DOCTOR_READINESS_AGGREGATOR_POLICY
+};

package/src/handler/effects.js

@@ -0,0 +1,446 @@
+'use strict';
+
+const ROUTE_HANDLER_EFFECT_PLAN_VERSION = 'pulsewasm.route-handler-effect-plan.v1';
+const ROUTE_HANDLER_EFFECT_PLAN_PHASE = '30';
+const ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT = 'route-handler-effect-plan.json';
+const ROUTE_HANDLER_NODE_EFFECT_PROOF_VERSION = 'pulsewasm.route-handler-node-effect-proof.v1';
+const ROUTE_HANDLER_NODE_EFFECT_PROOF_PHASE = '32';
+const ROUTE_HANDLER_NODE_EFFECT_PROOF_ARTIFACT = 'node-route-handler-effect-proof.json';
+const ROUTE_HANDLER_NODE_EFFECT_RUNTIME_VERSION = 'pulsewasm.route-handler-node-effect-runtime.v1';
+const ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_VERSION = 'pulsewasm.route-handler-node-live-origin-effect-proof.v1';
+const ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_PHASE = '37';
+const ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_ARTIFACT = 'node-live-origin-route-handler-effect-proof.json';
+const ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_RUNTIME_VERSION = 'pulsewasm.route-handler-node-live-origin-effect-runtime.v1';
+const ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_VERSION = 'pulsewasm.route-handler-node-compiled-effect-bridge.v1';
+const ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_PHASE = '38';
+const ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_ARTIFACT = 'node-compiled-route-handler-effect-bridge.json';
+const ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_RUNTIME_VERSION = 'pulsewasm.route-handler-node-compiled-effect-bridge-runtime.v1';
+const ROUTE_HANDLER_FASTLY_EFFECT_PROOF_VERSION = 'pulsewasm.route-handler-fastly-effect-proof.v1';
+const ROUTE_HANDLER_FASTLY_EFFECT_PROOF_PHASE = '33';
+const ROUTE_HANDLER_FASTLY_EFFECT_PROOF_ARTIFACT = 'fastly-route-handler-effect-proof.json';
+const ROUTE_HANDLER_FASTLY_EFFECT_RUNTIME_VERSION = 'pulsewasm.route-handler-fastly-effect-runtime.v1';
+const ROUTE_HANDLER_FASTLY_EFFECT_PROVIDER_CONFIG_VERSION = 'pulsewasm.route-handler-fastly-effect-provider-config.v1';
+const ROUTE_HANDLER_EFFECT_CONTRACT_ID = 'pulse.route-handler-effects';
+
+const ROUTE_HANDLER_EFFECT_PLAN_SCOPE = Object.freeze({
+  planOnly: true,
+  runtimeBehaviorChanged: false,
+  providerBehaviorImplemented: false,
+  compiledWasmEffectExecutionImplemented: false,
+  languageLevelAsync: false,
+  promises: false,
+  asyncAwait: false,
+  asyncify: false,
+  hiddenScheduler: false
+});
+
+const ROUTE_HANDLER_NODE_EFFECT_PROOF_SCOPE = Object.freeze({
+  provider: 'node',
+  compilerOwnsProviderBehavior: false,
+  compilerOrchestrationOnly: true,
+  providerBehaviorImplemented: true,
+  backendFetchProviderExecutionImplemented: true,
+  responseHandleSurfaceImplemented: true,
+  continuationContextImplemented: true,
+  directProviderSmoke: true,
+  routeEffectPlanRequired: true,
+  compiledWasmEffectExecutionImplemented: false,
+  compiledWasmSuspendResumeBridgeImplemented: false,
+  languageLevelAsync: false,
+  promises: false,
+  asyncAwait: false,
+  asyncify: false,
+  actualNetworkFetch: false,
+  localFixtureFetch: true
+});
+
+const ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_SCOPE = Object.freeze({
+  provider: 'node',
+  compilerOwnsProviderBehavior: false,
+  compilerOrchestrationOnly: true,
+  providerBehaviorImplemented: true,
+  compilerOwnsProviderBehavior: false,
+  backendFetchProviderExecutionImplemented: true,
+  liveOriginFetchImplemented: true,
+  responseHandleSurfaceImplemented: true,
+  continuationContextImplemented: true,
+  directProviderSmoke: true,
+  routeEffectPlanRequired: true,
+  compiledWasmEffectExecutionImplemented: false,
+  compiledWasmSuspendResumeBridgeImplemented: false,
+  languageLevelAsync: false,
+  promises: false,
+  asyncAwait: false,
+  asyncify: false,
+  actualNetworkFetch: true,
+  localFixtureFetch: false,
+  bootstrapOriginRequired: true
+});
+
+const ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_SCOPE = Object.freeze({
+  provider: 'node',
+  compilerOwnsProviderBehavior: false,
+  compilerOrchestrationOnly: true,
+  providerBehaviorImplemented: true,
+  backendFetchProviderExecutionImplemented: true,
+  liveOriginFetchImplemented: true,
+  responseHandleSurfaceImplemented: true,
+  continuationContextImplemented: true,
+  routeEffectPlanRequired: true,
+  compiledWasmEffectExecutionImplemented: true,
+  compiledWasmSuspendResumeBridgeImplemented: true,
+  compiledWasmContinuationReentryImplemented: true,
+  compiledWasmResolvedHandleInjectionImplemented: true,
+  directProviderSmoke: false,
+  languageLevelAsync: false,
+  promises: false,
+  asyncAwait: false,
+  asyncify: false,
+  actualNetworkFetch: true,
+  localFixtureFetch: false,
+  bootstrapOriginRequired: true,
+  singleEffectGroup: true,
+  namedObjectEffectGroup: true,
+  arrayEffectGroup: false
+});
+
+const ROUTE_HANDLER_FASTLY_EFFECT_PROOF_SCOPE = Object.freeze({
+  provider: 'fastly',
+  providerBehaviorImplemented: true,
+  compilerOwnsProviderBehavior: false,
+  backendFetchProviderExecutionImplemented: true,
+  responseHandleSurfaceImplemented: true,
+  continuationContextImplemented: true,
+  directProviderSmoke: true,
+  routeEffectPlanRequired: true,
+  providerConfigMappingImplemented: true,
+  symbolicBackendRefs: true,
+  symbolicConfigSecretRefs: true,
+  compiledWasmEffectExecutionImplemented: false,
+  compiledWasmSuspendResumeBridgeImplemented: false,
+  languageLevelAsync: false,
+  promises: false,
+  asyncAwait: false,
+  asyncify: false,
+  actualNetworkFetch: false,
+  localFixtureFetch: true
+});
+
+const ROUTE_HANDLER_EFFECT_GROUP_SHAPES = Object.freeze({
+  single: {
+    status: 'implemented-plan',
+    authoringShape: 'ctx.resolve(ctx.fetch("backend", requestSpec), afterFetch)',
+    resultAccess: 'ctx.resolved()'
+  },
+  namedObject: {
+    status: 'implemented-plan',
+    authoringShape: 'ctx.resolve({ user: ctx.fetch("users", requestSpec) }, afterDashboard)',
+    resultAccess: 'ctx.resolved("user")'
+  },
+  array: {
+    status: 'reserved-with-diagnostic',
+    authoringShape: 'ctx.resolve([ctx.fetch(...)], afterFetch)',
+    diagnostic: 'PULSEWASM_RESOLVE_ARRAY_GROUP_RESERVED'
+  }
+});
+
+const ROUTE_HANDLER_EFFECT_ALLOWED_METHODS = Object.freeze(['GET', 'HEAD', 'POST']);
+const ROUTE_HANDLER_EFFECT_KIND_REGISTRY = Object.freeze({
+  backendFetch: {
+    kind: 'backend-fetch',
+    publicSurface: 'ctx.fetch("backendKey", requestSpec)',
+    status: 'planned-only',
+    requiredCapability: 'backend-fetch',
+    hostOwned: true,
+    providerExecution: 'future-provider-proof',
+    payload: {
+      backend: 'literal backend key',
+      request: 'static object literal request spec',
+      method: 'literal GET/HEAD/POST for the MVP plan',
+      path: 'literal/concat/ctx.param expression tree'
+    }
+  }
+});
+
+const ROUTE_HANDLER_CONTEXT_SURFACE = Object.freeze({
+  sync: [
+    'ctx.param',
+    'ctx.paramI32',
+    'ctx.request.method',
+    'ctx.request.path',
+    'ctx.request.header.first',
+    'ctx.request.header.count',
+    'ctx.request.header.at',
+    'ctx.response.header.set',
+    'ctx.response.header.append',
+    'ctx.response.header.delete',
+    'ctx.result.text',
+    'ctx.result.jsonText',
+    'ctx.result.empty',
+    'ctx.error',
+    'next',
+    'next(error)'
+  ],
+  effect: [
+    'ctx.fetch',
+    'ctx.resolve',
+    'ctx.resolved'
+  ],
+  resolvedFetchResponse: [
+    'status',
+    'ok',
+    'header',
+    'text',
+    'jsonText',
+    'json'
+  ],
+  reservedResolvedFetchResponse: [
+    'bytes',
+    'stream'
+  ],
+  rejected: [
+    'await ctx.fetch(...)',
+    'ctx.fetch(...).then(...)',
+    'inline resolve continuation callbacks',
+    'captured continuation closures',
+    'dynamic backend keys',
+    'dynamic effect names',
+    'computed request objects',
+    'Promise',
+    'async function',
+    'global fetch',
+    'bare defer keyword'
+  ]
+});
+
+const ROUTE_HANDLER_EFFECT_DIAGNOSTICS = Object.freeze({
+  resolveContinuationMustBeTopLevel: 'PULSEWASM_RESOLVE_CONTINUATION_MUST_BE_TOP_LEVEL',
+  resolveContinuationMissing: 'PULSEWASM_RESOLVE_CONTINUATION_MISSING',
+  resolveEffectUnsupported: 'PULSEWASM_RESOLVE_EFFECT_UNSUPPORTED',
+  resolveObjectKeyUnsupported: 'PULSEWASM_RESOLVE_OBJECT_KEY_UNSUPPORTED',
+  resolveArrayGroupReserved: 'PULSEWASM_RESOLVE_ARRAY_GROUP_RESERVED',
+  fetchBackendMustBeLiteral: 'PULSEWASM_FETCH_BACKEND_MUST_BE_LITERAL',
+  fetchRequestMustBeObject: 'PULSEWASM_FETCH_REQUEST_MUST_BE_OBJECT',
+  fetchMethodMustBeLiteral: 'PULSEWASM_FETCH_METHOD_MUST_BE_LITERAL',
+  fetchMethodUnsupported: 'PULSEWASM_FETCH_METHOD_UNSUPPORTED',
+  backendMethodUnsupported: 'PULSEWASM_BACKEND_METHOD_UNSUPPORTED',
+  backendRequestBodyModeUnsupported: 'PULSEWASM_BACKEND_REQUEST_BODY_MODE_UNSUPPORTED',
+  schemaEncodeRefRequired: 'PULSEWASM_SCHEMA_ENCODE_REF_REQUIRED',
+  schemaEncodeDynamicSchemaUnsupported: 'PULSEWASM_SCHEMA_ENCODE_DYNAMIC_SCHEMA_UNSUPPORTED',
+  fetchJsonBodySchemaEncodeRequired: 'PULSEWASM_FETCH_JSON_BODY_SCHEMA_ENCODE_REQUIRED',
+  requestBodyBinaryReserved: 'PULSEWASM_REQUEST_BODY_BINARY_RESERVED',
+  requestBodyStreamReserved: 'PULSEWASM_REQUEST_BODY_STREAM_RESERVED',
+  requestBodyMultipartReserved: 'PULSEWASM_REQUEST_BODY_MULTIPART_RESERVED',
+  fetchPathUnsupported: 'PULSEWASM_FETCH_PATH_UNSUPPORTED',
+  fetchHeadersUnsupported: 'PULSEWASM_FETCH_HEADERS_UNSUPPORTED',
+  handlerSourceMissing: 'PULSEWASM_ROUTE_EFFECT_HANDLER_SOURCE_MISSING',
+  resolvedResultUnknownName: 'PULSEWASM_RESOLVED_RESULT_UNKNOWN_NAME',
+  resolvedResponseModeReserved: 'PULSEWASM_RESOLVED_RESPONSE_MODE_RESERVED',
+  unsupportedLanguageAsync: 'PULSEWASM_ROUTE_EFFECT_ASYNC_UNSUPPORTED',
+  nodeEffectPlanRequired: 'PULSEWASM_NODE_ROUTE_EFFECT_PLAN_REQUIRED',
+  nodeEffectNoPlannedEffects: 'PULSEWASM_NODE_ROUTE_EFFECT_NO_PLANNED_EFFECTS',
+  nodeEffectRouteNotFound: 'PULSEWASM_NODE_ROUTE_EFFECT_ROUTE_NOT_FOUND',
+  nodeEffectContinuationMissing: 'PULSEWASM_NODE_ROUTE_EFFECT_CONTINUATION_MISSING',
+  nodeEffectBackendMissing: 'PULSEWASM_NODE_ROUTE_EFFECT_BACKEND_MISSING',
+  nodeEffectBackendResponseMissing: 'PULSEWASM_NODE_ROUTE_EFFECT_BACKEND_RESPONSE_MISSING',
+  nodeEffectUnsupportedMethod: 'PULSEWASM_NODE_ROUTE_EFFECT_UNSUPPORTED_METHOD',
+  nodeEffectPathUnsupported: 'PULSEWASM_NODE_ROUTE_EFFECT_PATH_UNSUPPORTED',
+  nodeEffectResolvedNameMissing: 'PULSEWASM_NODE_ROUTE_EFFECT_RESOLVED_NAME_MISSING',
+  nodeEffectSmokeFailed: 'PULSEWASM_NODE_ROUTE_EFFECT_SMOKE_FAILED',
+  nodeLiveOriginRequired: 'PULSEWASM_NODE_ROUTE_EFFECT_LIVE_ORIGIN_REQUIRED',
+  nodeLiveOriginFetchFailed: 'PULSEWASM_NODE_ROUTE_EFFECT_LIVE_ORIGIN_FETCH_FAILED',
+  nodeLiveOriginInvalidUrl: 'PULSEWASM_NODE_ROUTE_EFFECT_LIVE_ORIGIN_INVALID_URL',
+  nodeCompiledBridgePlanRequired: 'PULSEWASM_NODE_COMPILED_ROUTE_EFFECT_BRIDGE_PLAN_REQUIRED',
+  nodeCompiledBridgeNoPlannedEffects: 'PULSEWASM_NODE_COMPILED_ROUTE_EFFECT_BRIDGE_NO_PLANNED_EFFECTS',
+  nodeCompiledBridgeAscMissing: 'PULSEWASM_NODE_COMPILED_ROUTE_EFFECT_BRIDGE_ASC_MISSING',
+  nodeCompiledBridgeCompileFailed: 'PULSEWASM_NODE_COMPILED_ROUTE_EFFECT_BRIDGE_COMPILE_FAILED',
+  nodeCompiledBridgeSmokeFailed: 'PULSEWASM_NODE_COMPILED_ROUTE_EFFECT_BRIDGE_SMOKE_FAILED',
+  fastlyEffectPlanRequired: 'PULSEWASM_FASTLY_ROUTE_EFFECT_PLAN_REQUIRED',
+  fastlyEffectNoPlannedEffects: 'PULSEWASM_FASTLY_ROUTE_EFFECT_NO_PLANNED_EFFECTS',
+  fastlyEffectRouteNotFound: 'PULSEWASM_FASTLY_ROUTE_EFFECT_ROUTE_NOT_FOUND',
+  fastlyEffectContinuationMissing: 'PULSEWASM_FASTLY_ROUTE_EFFECT_CONTINUATION_MISSING',
+  fastlyEffectBackendMissing: 'PULSEWASM_FASTLY_ROUTE_EFFECT_BACKEND_MISSING',
+  fastlyEffectBackendResponseMissing: 'PULSEWASM_FASTLY_ROUTE_EFFECT_BACKEND_RESPONSE_MISSING',
+  fastlyEffectUnsupportedMethod: 'PULSEWASM_FASTLY_ROUTE_EFFECT_UNSUPPORTED_METHOD',
+  fastlyEffectPathUnsupported: 'PULSEWASM_FASTLY_ROUTE_EFFECT_PATH_UNSUPPORTED',
+  fastlyEffectResolvedNameMissing: 'PULSEWASM_FASTLY_ROUTE_EFFECT_RESOLVED_NAME_MISSING',
+  fastlyEffectSmokeFailed: 'PULSEWASM_FASTLY_ROUTE_EFFECT_SMOKE_FAILED'
+});
+
+const ROUTE_HANDLER_EFFECT_LIFECYCLE = Object.freeze({
+  handlerRunsSynchronously: true,
+  resolveReturnsEffectRequest: true,
+  hostExecutesEffectGroup: true,
+  continuationReentryIsExplicit: true,
+  continuationReadsResultsThroughCtx: true,
+  continuationMayReturnResultOrAnotherResolveRequest: 'reserved',
+  wasmCallStackCaptured: false,
+  continuationTokenUserVisible: false
+});
+
+function defaultRouteHandlerEffectPolicy() {
+  return {
+    ...ROUTE_HANDLER_EFFECT_PLAN_SCOPE,
+    contractId: ROUTE_HANDLER_EFFECT_CONTRACT_ID,
+    artifact: ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT,
+    nodeProviderProofArtifact: ROUTE_HANDLER_NODE_EFFECT_PROOF_ARTIFACT,
+    nodeProviderRuntimeVersion: ROUTE_HANDLER_NODE_EFFECT_RUNTIME_VERSION,
+    nodeLiveOriginProviderProofArtifact: ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_ARTIFACT,
+    nodeLiveOriginProviderRuntimeVersion: ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_RUNTIME_VERSION,
+    nodeCompiledEffectBridgeArtifact: ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_ARTIFACT,
+    nodeCompiledEffectBridgeRuntimeVersion: ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_RUNTIME_VERSION,
+    fastlyProviderProofArtifact: ROUTE_HANDLER_FASTLY_EFFECT_PROOF_ARTIFACT,
+    fastlyProviderRuntimeVersion: ROUTE_HANDLER_FASTLY_EFFECT_RUNTIME_VERSION,
+    allowedMethods: [...ROUTE_HANDLER_EFFECT_ALLOWED_METHODS],
+    groupShapes: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_GROUP_SHAPES)),
+    effectKinds: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_KIND_REGISTRY)),
+    contextSurface: JSON.parse(JSON.stringify(ROUTE_HANDLER_CONTEXT_SURFACE)),
+    lifecycle: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_LIFECYCLE))
+  };
+}
+
+function defaultRouteHandlerNodeEffectProofPolicy() {
+  return {
+    ...ROUTE_HANDLER_NODE_EFFECT_PROOF_SCOPE,
+    contractId: ROUTE_HANDLER_EFFECT_CONTRACT_ID,
+    artifact: ROUTE_HANDLER_NODE_EFFECT_PROOF_ARTIFACT,
+    sourcePlanArtifact: ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT,
+    runtimeVersion: ROUTE_HANDLER_NODE_EFFECT_RUNTIME_VERSION,
+    allowedMethods: [...ROUTE_HANDLER_EFFECT_ALLOWED_METHODS],
+    groupShapes: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_GROUP_SHAPES)),
+    resolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.resolvedFetchResponse],
+    reservedResolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.reservedResolvedFetchResponse],
+    lifecycle: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_LIFECYCLE)),
+    providerProof: {
+      owner: '@pulse-compute/provider-node',
+      mode: 'direct-provider-smoke-connected-to-route-handler-effect-plan',
+      executesBackendFetchEffects: true,
+      suppliesResolvedResponseHandles: true,
+      reentersContinuationInCompiledWasm: false,
+      continuationContextCanCallTopLevelHandlers: true
+    }
+  };
+}
+
+
+function defaultRouteHandlerNodeLiveOriginEffectProofPolicy() {
+  return {
+    ...ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_SCOPE,
+    contractId: ROUTE_HANDLER_EFFECT_CONTRACT_ID,
+    artifact: ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_ARTIFACT,
+    sourcePlanArtifact: ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT,
+    runtimeVersion: ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_RUNTIME_VERSION,
+    allowedMethods: [...ROUTE_HANDLER_EFFECT_ALLOWED_METHODS],
+    groupShapes: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_GROUP_SHAPES)),
+    resolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.resolvedFetchResponse],
+    reservedResolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.reservedResolvedFetchResponse],
+    lifecycle: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_LIFECYCLE)),
+    providerProof: {
+      owner: '@pulse-compute/provider-node',
+      mode: 'direct-provider-smoke-with-live-local-origin',
+      executesBackendFetchEffects: true,
+      suppliesResolvedResponseHandles: true,
+      reentersContinuationInCompiledWasm: false,
+      continuationContextCanCallTopLevelHandlers: true,
+      actualNetworkFetch: true,
+      localFixtureFetch: false,
+      userAuthoredAsync: false
+    }
+  };
+}
+
+function defaultRouteHandlerNodeCompiledEffectBridgePolicy() {
+  return {
+    ...ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_SCOPE,
+    contractId: ROUTE_HANDLER_EFFECT_CONTRACT_ID,
+    artifact: ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_ARTIFACT,
+    sourcePlanArtifact: ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT,
+    runtimeVersion: ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_RUNTIME_VERSION,
+    allowedMethods: [...ROUTE_HANDLER_EFFECT_ALLOWED_METHODS],
+    groupShapes: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_GROUP_SHAPES)),
+    resolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.resolvedFetchResponse],
+    reservedResolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.reservedResolvedFetchResponse],
+    lifecycle: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_LIFECYCLE)),
+    providerProof: {
+      owner: '@pulse-compute/provider-node',
+      mode: 'compiled-wasm-resolve-resume-bridge-with-live-local-origin',
+      executesBackendFetchEffects: true,
+      suppliesResolvedResponseHandles: true,
+      reentersContinuationInCompiledWasm: true,
+      actualNetworkFetch: true,
+      localFixtureFetch: false,
+      userAuthoredAsync: false,
+      promises: false,
+      asyncAwait: false,
+      asyncify: false
+    }
+  };
+}
+
+function defaultRouteHandlerFastlyEffectProofPolicy() {
+  return {
+    ...ROUTE_HANDLER_FASTLY_EFFECT_PROOF_SCOPE,
+    contractId: ROUTE_HANDLER_EFFECT_CONTRACT_ID,
+    artifact: ROUTE_HANDLER_FASTLY_EFFECT_PROOF_ARTIFACT,
+    sourcePlanArtifact: ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT,
+    runtimeVersion: ROUTE_HANDLER_FASTLY_EFFECT_RUNTIME_VERSION,
+    providerConfigVersion: ROUTE_HANDLER_FASTLY_EFFECT_PROVIDER_CONFIG_VERSION,
+    allowedMethods: [...ROUTE_HANDLER_EFFECT_ALLOWED_METHODS],
+    groupShapes: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_GROUP_SHAPES)),
+    resolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.resolvedFetchResponse],
+    reservedResolvedFetchResponseSurface: [...ROUTE_HANDLER_CONTEXT_SURFACE.reservedResolvedFetchResponse],
+    lifecycle: JSON.parse(JSON.stringify(ROUTE_HANDLER_EFFECT_LIFECYCLE)),
+    providerProof: {
+      owner: '@pulse-compute/provider-fastly',
+      mode: 'direct-provider-smoke-connected-to-route-handler-effect-plan',
+      executesBackendFetchEffects: true,
+      suppliesResolvedResponseHandles: true,
+      reentersContinuationInCompiledWasm: false,
+      continuationContextCanCallTopLevelHandlers: true,
+      providerConfigMapping: 'symbolic-backend-fetch-bindings',
+      symbolicBackendRefs: true,
+      symbolicConfigSecretRefs: true,
+      actualNetworkFetch: false
+    }
+  };
+}
+
+module.exports = {
+  ROUTE_HANDLER_EFFECT_PLAN_VERSION,
+  ROUTE_HANDLER_EFFECT_PLAN_PHASE,
+  ROUTE_HANDLER_EFFECT_PLAN_ARTIFACT,
+  ROUTE_HANDLER_NODE_EFFECT_PROOF_VERSION,
+  ROUTE_HANDLER_NODE_EFFECT_PROOF_PHASE,
+  ROUTE_HANDLER_NODE_EFFECT_PROOF_ARTIFACT,
+  ROUTE_HANDLER_NODE_EFFECT_RUNTIME_VERSION,
+  ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_VERSION,
+  ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_VERSION,
+  ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_PHASE,
+  ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_PHASE,
+  ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_ARTIFACT,
+  ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_ARTIFACT,
+  ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_RUNTIME_VERSION,
+  ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_RUNTIME_VERSION,
+  ROUTE_HANDLER_FASTLY_EFFECT_PROOF_VERSION,
+  ROUTE_HANDLER_FASTLY_EFFECT_PROOF_PHASE,
+  ROUTE_HANDLER_FASTLY_EFFECT_PROOF_ARTIFACT,
+  ROUTE_HANDLER_FASTLY_EFFECT_RUNTIME_VERSION,
+  ROUTE_HANDLER_FASTLY_EFFECT_PROVIDER_CONFIG_VERSION,
+  ROUTE_HANDLER_EFFECT_CONTRACT_ID,
+  ROUTE_HANDLER_EFFECT_PLAN_SCOPE,
+  ROUTE_HANDLER_NODE_EFFECT_PROOF_SCOPE,
+  ROUTE_HANDLER_NODE_LIVE_ORIGIN_EFFECT_PROOF_SCOPE,
+  ROUTE_HANDLER_NODE_COMPILED_EFFECT_BRIDGE_SCOPE,
+  ROUTE_HANDLER_FASTLY_EFFECT_PROOF_SCOPE,
+  ROUTE_HANDLER_EFFECT_GROUP_SHAPES,
+  ROUTE_HANDLER_EFFECT_ALLOWED_METHODS,
+  ROUTE_HANDLER_EFFECT_KIND_REGISTRY,
+  ROUTE_HANDLER_CONTEXT_SURFACE,
+  ROUTE_HANDLER_EFFECT_DIAGNOSTICS,
+  ROUTE_HANDLER_EFFECT_LIFECYCLE,
+  defaultRouteHandlerEffectPolicy,
+  defaultRouteHandlerNodeEffectProofPolicy,
+  defaultRouteHandlerNodeLiveOriginEffectProofPolicy,
+  defaultRouteHandlerNodeCompiledEffectBridgePolicy,
+  defaultRouteHandlerFastlyEffectProofPolicy
+};

package/src/handler/io-lifecycle.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const HANDLER_IO_LIFECYCLE_PLAN_VERSION = 'pulsewasm.handler-io-lifecycle-plan.v1';
+const HANDLER_IO_LIFECYCLE_PLAN_PHASE = '36';
+const HANDLER_IO_LIFECYCLE_PLAN_ARTIFACT = 'handler-io-lifecycle-plan.json';
+const HANDLER_IO_LIFECYCLE_CONTRACT_ID = 'pulse.handler-io-lifecycle';
+
+const HANDLER_IO_LIFECYCLE_SCOPE = Object.freeze({
+  planOnly: true,
+  unifiesRouteContextPlan: true,
+  unifiesRouteEffectPlan: true,
+  referencesSchemaJson: true,
+  providerBehaviorImplemented: false,
+  runtimeBehaviorChanged: false,
+  compiledWasmEffectExecutionImplemented: false,
+  requestBodyRuntimeImplemented: false,
+  backendJsonRequestBodyImplemented: true,
+  binaryRequestBodyParsing: false,
+  streamRequestBodyParsing: false,
+  asyncAwait: false,
+  promises: false,
+  asyncify: false
+});
+
+const HANDLER_IO_LIFECYCLE_STAGES = Object.freeze([
+  'route-match',
+  'sync-context-read',
+  'lazy-request-body-decode',
+  'backend-origin-effect',
+  'continuation-reentry',
+  'origin-response-decode',
+  'final-response-encode'
+]);
+
+const HANDLER_IO_REQUEST_BODY_MODES = Object.freeze({
+  none: { status: 'implemented-now', description: 'route does not read a request body' },
+  schemaJson: { status: 'planned-only', surface: 'ctx.req.json("Schema") / ctx.req.parse("Schema")' },
+  genericJson: { status: 'planned-only', surface: 'ctx.req.json() with explicit as-json fallback' },
+  text: { status: 'reserved-with-diagnostic', surface: 'ctx.req.text() / ctx.request.bodyText()' },
+  binary: { status: 'reserved-with-diagnostic', surface: 'binary request body parsing' },
+  stream: { status: 'reserved-with-diagnostic', surface: 'stream request body parsing' }
+});
+
+const HANDLER_IO_BACKEND_REQUEST_BODY_MODES = Object.freeze({
+  none: { status: 'implemented-now', methods: ['GET', 'HEAD', 'POST'] },
+  json: { status: 'implemented-node-provider-proof', surface: 'ctx.fetch(..., { json: ctx.schema.encode("Schema", ref) })' },
+  text: { status: 'reserved-with-diagnostic', surface: 'ctx.fetch(..., { body/text })' },
+  binary: { status: 'reserved-with-diagnostic' },
+  stream: { status: 'reserved-with-diagnostic' }
+});
+
+const HANDLER_IO_ORIGIN_RESPONSE_BODY_MODES = Object.freeze({
+  text: { status: 'implemented-provider-proof', surface: 'ctx.resolved().text()' },
+  jsonText: { status: 'implemented-provider-proof', surface: 'ctx.resolved().jsonText()' },
+  status: { status: 'implemented-provider-proof', surface: 'ctx.resolved().status() / ok()' },
+  header: { status: 'implemented-provider-proof', surface: 'ctx.resolved().header(name)' },
+  json: { status: 'implemented-provider-proof', surface: 'ctx.resolved().json("Schema")' },
+  binary: { status: 'reserved-with-diagnostic', surface: 'ctx.resolved().bytes()' },
+  stream: { status: 'reserved-with-diagnostic', surface: 'ctx.resolved().stream()' }
+});
+
+const HANDLER_IO_FINAL_RESPONSE_MODES = Object.freeze({
+  text: { status: 'implemented-now', surface: 'ctx.result.text(status, body, opts)' },
+  jsonText: { status: 'implemented-now', surface: 'ctx.result.jsonText(status, jsonText, opts)' },
+  empty: { status: 'implemented-now', surface: 'ctx.result.empty(status, opts)' },
+  schemaJson: { status: 'implemented-compiled-runtime', surface: 'ctx.result.json("Schema", ref, opts)' },
+  passthrough: { status: 'reserved-with-diagnostic', surface: 'ctx.result.from(origin, policy)' },
+  binary: { status: 'reserved-with-diagnostic' },
+  stream: { status: 'reserved-with-diagnostic' }
+});
+
+const HANDLER_IO_SCHEMA_SURFACE = Object.freeze({
+  requestDecode: ['ctx.req.json("Schema")', 'ctx.req.parse("Schema")'],
+  genericRequestDecode: ['ctx.req.json()'],
+  originDecode: ['ctx.resolved("name").json("Schema")'],
+  encode: ['ctx.schema.encode("Schema", ref)', 'ctx.result.json("Schema", ref, opts)'],
+  currentStatus: 'implemented-for-result-origin-decode-and-backend-json-request-bodies',
+  automaticSchemaGeneration: false,
+  arbitraryJsObjectInference: false
+});
+
+const HANDLER_IO_LAZY_EVALUATION_POLICY = Object.freeze({
+  requestBodyRead: 'route-demand-only',
+  requestBodyParse: 'on-demand-helper-only',
+  requestBodyCache: 'per-request body/decode refs',
+  backendEffects: 'explicit ctx.resolve boundary only',
+  finalResponseEncode: 'only when selected result is returned',
+  eagerBodyParsing: false,
+  implicitGenericParserBundle: false
+});
+
+const HANDLER_IO_LIFECYCLE_DIAGNOSTICS = Object.freeze({
+  contextPlanMissing: 'PULSEWASM_HANDLER_IO_CONTEXT_PLAN_MISSING',
+  effectPlanMissing: 'PULSEWASM_HANDLER_IO_EFFECT_PLAN_MISSING',
+  routePlanMissing: 'PULSEWASM_HANDLER_IO_ROUTE_PLAN_MISSING',
+  schemaParserUnavailable: 'PULSEWASM_HANDLER_IO_SCHEMA_PARSER_UNAVAILABLE',
+  requestBodyReserved: 'PULSEWASM_HANDLER_IO_REQUEST_BODY_RESERVED',
+  backendRequestBodyReserved: 'PULSEWASM_HANDLER_IO_BACKEND_REQUEST_BODY_RESERVED',
+  responseBodyReserved: 'PULSEWASM_HANDLER_IO_RESPONSE_BODY_RESERVED',
+  unsupportedSchemaSurface: 'PULSEWASM_HANDLER_IO_SCHEMA_SURFACE_UNSUPPORTED'
+});
+
+function defaultHandlerIoLifecyclePolicy() {
+  return {
+    ...HANDLER_IO_LIFECYCLE_SCOPE,
+    contractId: HANDLER_IO_LIFECYCLE_CONTRACT_ID,
+    artifact: HANDLER_IO_LIFECYCLE_PLAN_ARTIFACT,
+    stages: [...HANDLER_IO_LIFECYCLE_STAGES],
+    requestBodyModes: JSON.parse(JSON.stringify(HANDLER_IO_REQUEST_BODY_MODES)),
+    backendRequestBodyModes: JSON.parse(JSON.stringify(HANDLER_IO_BACKEND_REQUEST_BODY_MODES)),
+    originResponseBodyModes: JSON.parse(JSON.stringify(HANDLER_IO_ORIGIN_RESPONSE_BODY_MODES)),
+    finalResponseModes: JSON.parse(JSON.stringify(HANDLER_IO_FINAL_RESPONSE_MODES)),
+    schemaSurface: JSON.parse(JSON.stringify(HANDLER_IO_SCHEMA_SURFACE)),
+    lazyEvaluation: JSON.parse(JSON.stringify(HANDLER_IO_LAZY_EVALUATION_POLICY)),
+    diagnostics: { ...HANDLER_IO_LIFECYCLE_DIAGNOSTICS }
+  };
+}
+
+module.exports = {
+  HANDLER_IO_LIFECYCLE_PLAN_VERSION,
+  HANDLER_IO_LIFECYCLE_PLAN_PHASE,
+  HANDLER_IO_LIFECYCLE_PLAN_ARTIFACT,
+  HANDLER_IO_LIFECYCLE_CONTRACT_ID,
+  HANDLER_IO_LIFECYCLE_SCOPE,
+  HANDLER_IO_LIFECYCLE_STAGES,
+  HANDLER_IO_REQUEST_BODY_MODES,
+  HANDLER_IO_BACKEND_REQUEST_BODY_MODES,
+  HANDLER_IO_ORIGIN_RESPONSE_BODY_MODES,
+  HANDLER_IO_FINAL_RESPONSE_MODES,
+  HANDLER_IO_SCHEMA_SURFACE,
+  HANDLER_IO_LAZY_EVALUATION_POLICY,
+  HANDLER_IO_LIFECYCLE_DIAGNOSTICS,
+  defaultHandlerIoLifecyclePolicy
+};