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

package/src/toolchain/config.js

@@ -1,4 +1,6 @@
 'use strict';
+const { normalizeFastlyMaxWasmBytes } = require('../build/wasm-budget.js');
+const { normalizeFastlyS3 } = require('./s3.js');
 
 function providerConfigError(code, message, detail) {
   const error = new TypeError(message);
@@ -32,11 +34,15 @@ function normalizeFastlyProviderConfig(value) {
     : {};
   return Object.freeze({
     kind: 'fastly',
+    bodyForwarding: require('./body-forwarding.js').normalizeBodyForwarding(input.bodyForwarding, input.maxDurationMs),
+    maxDurationMs: require('@pulse-compute/runtime/host').normalizeRequestDuration(input.maxDurationMs),
     version: input.version ? String(input.version) : undefined,
     bindings: Object.freeze({
+      ...(bindings.logEndpoint === undefined ? {} : { logEndpoint: require('./logging.js').normalizeFastlyLogEndpoint(bindings.logEndpoint) }),
       configStore: String(bindings.configStore || 'pulse_config'),
       secretStore: String(bindings.secretStore || 'pulse_secrets'),
       kv: normalizeStringMap(bindings.kv, 'PULSE_FASTLY_KV_BINDINGS_INVALID'),
+      s3: normalizeFastlyS3(bindings.s3),
       backends: normalizeStringMap(bindings.backends, 'PULSE_FASTLY_BACKEND_BINDINGS_INVALID'),
       grip: Object.freeze({
         fanoutBackend: gripInput.fanoutBackend === undefined ? undefined : String(gripInput.fanoutBackend),
@@ -52,6 +58,7 @@ function normalizeFastlyProviderConfig(value) {
       dynamicBackends: bindings.dynamicBackends === true
     }),
     build: Object.freeze({
+      maxWasmBytes: normalizeFastlyMaxWasmBytes(input.build?.maxWasmBytes),
       name: String(input.build && input.build.name || 'pulse-app'),
       description: String(input.build && input.build.description || 'Pulse application'),
       authors: Object.freeze(Array.isArray(input.build && input.build.authors) ? input.build.authors.map(String) : [])
@@ -65,6 +72,8 @@ function fastlyProjectConfigDocument(config) {
   return Object.freeze({
     kind: 'fastly',
     bindings: config.bindings,
+    maxDurationMs: config.maxDurationMs,
+    bodyForwarding: config.bodyForwarding,
     build: config.build,
     local: config.local,
     providerSpecificUserland: false
@@ -98,6 +107,13 @@ const FASTLY_PROJECT_CONFIG_REFERENCE = Object.freeze({
     })
   ]),
   fields: Object.freeze([
+    Object.freeze({ section: 'fastly', path: 'fastly.logEndpoint', type: 'string', default: 'omitted (stdout)', scope: 'fastly() facade; conventional profiles use fastly.bindings.logEndpoint', description: 'One case-sensitive named production log stream, 1–255 UTF-8 bytes, excluding stdout, stderr, fst_managed_ names and control characters. Records above 65536 UTF-8 bytes are dropped. One lookup and at most one write per record; errors and zero/short writes are dropped without retry or stdout fallback. Host acceptance does not prove downstream delivery.', diagnostics: Object.freeze(['PULSE_FASTLY_LOG_ENDPOINT_INVALID']) }),
+    Object.freeze({section:'fastly',path:'fastly.bodyForwarding',type:'object',default:'omitted',scope:'experimental Fastly Native forwarding',description:'Opt in to one terminal opaque POST with inline req.body() and a static backend. Requires maxDurationMs and both byte limits. Final close hands queued delivery to Fastly; it is not a client receipt.',diagnostics:Object.freeze(['PULSE_FASTLY_BODY_FORWARDING_INVALID'])}),
+    ...['requestMaxBytes','responseMaxBytes'].map(name => Object.freeze({section:'fastly',path:`fastly.bodyForwarding.${name}`,type:'integer',allowed:'1–1048576',default:'required with bodyForwarding',scope:'experimental Fastly Native forwarding',description:'Independent actual-byte bound, including EOF verification; no unbounded default. Fixed 16 KiB raw scratch is reused across the sequential upload and response pumps.'})),
+    Object.freeze({section:'fastly',path:'fastly.maxWasmBytes',type:'integer',allowed:'positive safe integer',default:'4194304 (4 MiB)',scope:'fastly() facade',description:'Facade option projected to build.maxWasmBytes. Conventional profiles configure fastly.build.maxWasmBytes.'}),
+    Object.freeze({section:'fastly',path:'fastly.build.maxWasmBytes',type:'integer',allowed:'positive safe integer',default:'4194304 (4 MiB)',scope:'Native final Wasm artifact',description:'Inclusive byte budget checked for newly compiled and reused artifacts. Raising it does not increase runtime memory or change Fastly service limits. The fastly() facade accepts maxWasmBytes.'}),
+    Object.freeze({section:'fastly',path:'fastly.maxDurationMs',type:'integer',allowed:'1–30000',default:'omitted',scope:'HTTP request execution',description:'One provider-owned monotonic budget through buffered response handoff; expiry attempts 504 before headers commit and never asserts rollback of dispatched writes. No CPU preemption or post-handoff delivery guarantee.'}),
+    Object.freeze({ section: 'fastly', path: 'fastly.bindings.s3', type: 'Readonly<Record<string, S3Binding & { backend: string }>>', default: '`{}`', scope: 'Fastly Native S3', description: 'Maps logical names to fixed HTTPS endpoint, bucket, region, named static backend, accessKeyIdSecret, secretAccessKeySecret, optional sessionTokenSecret, maxTextBytes (1–2097152, default 32768) and timeoutMs (1–30000, default 10000).', security: 'Credentials resolve through the configured Secret Store at execution. Dynamic backend authority and guest endpoint overrides are forbidden.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.configStore', type: 'string', default: '`pulse_config`', scope: 'Fastly config capability', description: 'Fastly Config Store resource name.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.secretStore', type: 'string', default: '`pulse_secrets`', scope: 'Fastly secret capability', description: 'Fastly Secret Store resource name.', security: 'The name is build metadata; secret values are never embedded by this option.' }),
     Object.freeze({ section: 'fastly', path: 'fastly.kv', type: 'Readonly<Record<string, string>>', default: '`{}`', scope: 'Fastly KV capability', description: 'Maps logical ctx.kv names to Fastly KV Store resource names.', diagnostics: Object.freeze(['PULSE_FASTLY_KV_BINDINGS_INVALID']) }),

package/src/toolchain/index.js

@@ -38,7 +38,8 @@ const packageManifest = require('../../package.json');
 const reportingTargetCapability = Object.freeze({
   supported: true,
   default: 'info',
-  levels: Object.freeze(['off', 'error', 'warn', 'info', 'debug'])
+  levels: Object.freeze(['off', 'error', 'warn', 'info', 'debug']),
+  destinations: Object.freeze(['stdout', 'configured-named-endpoint'])
 });
 
 const fastlyFinalWasmPolicy = defineFinalWasmPolicy({
@@ -124,6 +125,7 @@ function createDriver() {
           projectRoot: invocation.project.root,
           outDir: invocation.project.outDir,
           schemaBundle: invocation.javascript.schemaBundle,
+          binaryResources: invocation.javascript.binaryResources,
           providerConfig: invocation.providerConfig,
           reporting: invocation.javascript.reporting,
           strict: invocation.javascript.strict,
@@ -169,14 +171,32 @@ function createDriver() {
         runtimeClass: 'native',
         status: 'supported',
         capabilities: Object.freeze([
+          's3.head', 's3.getText', 's3.getBody',
+          'kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap', 'kv.list', 'kv.delete',
           'jwt.verify',
+          'jwt.sign',
           'jwt.verify.hs256',
           'jwt.verify.es256',
+          'jwt.verify.rs256',
           'secret.get',
           'time.wall-clock'
         ]),
         keyTypes: Object.freeze(['secret', 'jwk', 'jwks']),
         realizations: Object.freeze([
+          Object.freeze({
+            kind: 'package-native-application',
+            contractId: 'pulse.entities',
+            implementation: 'pulse.package-native-application.v1',
+            implemented: true,
+            automaticFallback: false
+          }),
+          Object.freeze({
+            kind: 'package-native-application',
+            contractId: 'pulse.mcp',
+            implementation: 'pulse.package-native-application.v2',
+            implemented: true,
+            automaticFallback: false
+          }),
           Object.freeze({
             kind: 'crypto-composed',
             realization: 'guest-source:pulse-hmac-as',
@@ -202,6 +222,19 @@ function createDriver() {
             guestUnitRequired: true,
             portable: true,
             automaticFallback: false
+          }),
+          Object.freeze({
+            kind: 'crypto-composed',
+            realization: 'guest-linked:pulse-rs256-bearssl-i31',
+            implementation: 'bearssl.0.6.rsa-i31.sha256.v1',
+            algorithms: Object.freeze(['RS256']),
+            keyTypes: Object.freeze(['jwk', 'jwks']),
+            implemented: true,
+            status: 'implemented-g4',
+            semanticOwner: '@pulse-compute/crypto',
+            guestUnitRequired: true,
+            portable: true,
+            automaticFallback: false
           })
         ]),
         jwt: Object.freeze({
@@ -221,7 +254,7 @@ function createDriver() {
         automaticFallback: false,
         crypto: defineCryptoTargetCapabilities({
           target: 'native',
-          algorithms: [{
+          algorithms: [...['SHA-256', 'HMAC-SHA256'].map((algorithm) => ({ algorithm, realization: 'guest-source:pulse-hmac-as', implemented: true, status: 'implemented-o2' })), {
             algorithm: 'HS256',
             realization: 'guest-source:pulse-hmac-as',
             implemented: true,
@@ -231,6 +264,11 @@ function createDriver() {
             realization: 'guest-linked:pulse-es256-rustcrypto-p256',
             implemented: true,
             status: 'implemented-g4'
+          }, {
+            algorithm: 'RS256',
+            realization: 'guest-linked:pulse-rs256-bearssl-i31',
+            implemented: true,
+            status: 'implemented-g4'
           }]
         }),
         finalWasmPolicy: fastlyFinalWasmPolicy,
@@ -240,8 +278,9 @@ function createDriver() {
       javascript: FASTLY_JAVASCRIPT_TARGET_DESCRIPTOR
     }),
     execute: fastlyRuntime.executeCanonicalProgram,
+    prepareNativeExecution: require('./native-execution.js').prepareFastlyNativeExecution,
     createLoweringPlan(metadata, providerConfig = {}) {
-      return createFastlyLoweringPlan(metadata, providerConfig.bindings || {});
+      return createFastlyLoweringPlan(metadata, providerConfig.bindings || {}, providerConfig);
     },
     inspectRealization(invocation) {
       const realization = inspectFastlyCanonicalTarget({
@@ -255,6 +294,8 @@ function createDriver() {
         realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
         guestUnits: invocation.nativeArtifact.guestUnits,
         nativeOptimization: invocation.optimization,
+        elideJsonCacheArena: invocation.nativeArtifact.manifest.elideJsonCacheArena === true,
+        emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
         compileTimeoutMs: invocation.timeoutMs
       });
       const { native, ...publicRealization } = realization;
@@ -283,6 +324,8 @@ function createDriver() {
         realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
         guestUnits: invocation.nativeArtifact.guestUnits,
         nativeOptimization: invocation.optimization,
+        elideJsonCacheArena: invocation.nativeArtifact.manifest.elideJsonCacheArena === true,
+        emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
         compileTimeoutMs: invocation.timeoutMs
       });
       const providerBuild = writeFastlyCanonicalTarget({
@@ -318,7 +361,7 @@ function createDriver() {
           providerPackage: providerBuild.packageFile,
           providerSourceEntry: providerBuild.sourceEntryFile
         }),
-        build: providerBuild.build,
+        build: { ...providerBuild.build, reportAttribution: native.reportAttribution, buildObservation: native.buildObservation },
         realization: publicRealization,
         packaging: audit ? Object.freeze({
           version: PROVIDER_PACKAGING_AUDIT_VERSION,
@@ -329,7 +372,7 @@ function createDriver() {
       });
     },
     executionOptions(providerConfig = {}, values = {}) {
-      return { ...values, bindings: providerConfig.bindings };
+      return { ...values, maxDurationMs: providerConfig.maxDurationMs, bindings: providerConfig.bindings };
     }
   });
 }

package/src/toolchain/logging.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const MAX_LOG_BYTES = 65536;
+
+function normalizeFastlyLogEndpoint(value) {
+  if (value === undefined) return undefined;
+  if (typeof value !== 'string' || !value || value.length > 255 || value.trim() !== value
+      || new TextEncoder().encode(value).byteLength > 255 || /[\u0000-\u001f\u007f]/u.test(value)
+      || /[\ud800-\udfff]/u.test(value.replace(/[\ud800-\udbff][\udc00-\udfff]/g, ''))
+      || /^(?:stdout$|stderr$|fst_managed_)/i.test(value)) {
+    const error = new TypeError('Fastly logEndpoint must be a non-reserved endpoint name of 1–255 UTF-8 bytes without control characters or surrounding whitespace.');
+    error.code = 'PULSE_FASTLY_LOG_ENDPOINT_INVALID';
+    throw error;
+  }
+  return value;
+}
+
+module.exports = { normalizeFastlyLogEndpoint, MAX_LOG_BYTES };

package/src/toolchain/native-execution.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const { inspectFastlyCanonicalTarget } = require('../build/canonical-target.js');
+const { executeFastlyNativePlatformCapabilities } = require('../testing/native-platform-capabilities-host.js');
+const { createConditionalKvAuthority } = require('../testing/conditional-kv-host.js');
+
+// Execute the provider artifact against the existing fixture ABI. This is local
+// conformance evidence, never Viceroy or deployed Fastly acceptance.
+function prepareFastlyNativeExecution(invocation) {
+  const bindings = invocation.providerConfig.bindings;
+  const { native } = inspectFastlyCanonicalTarget({
+    plan: invocation.applicationPlan,
+    providerConfig: invocation.providerConfig,
+    projectRoot: invocation.project.root,
+    profile: invocation.project.profile,
+    targetDescriptor: invocation.selectedTarget,
+    synchronizedPackages: invocation.synchronizedPackages,
+    realizationArtifacts: invocation.nativeArtifact.realizationArtifacts,
+    guestUnits: invocation.nativeArtifact.guestUnits,
+    nativeOptimization: invocation.optimization,
+    elideJsonCacheArena: invocation.nativeArtifact.manifest.elideJsonCacheArena === true,
+    emitWat: invocation.nativeArtifact.manifest.wat?.emitted === true,
+    compileTimeoutMs: invocation.timeoutMs || undefined
+  });
+  const evidence = Object.freeze({
+    kind: 'fastly-native-fixture-abi',
+    provider: 'fastly',
+    target: 'fastly-compute-native',
+    wasmSha256: native.manifest.wasm.sha256,
+    providerRealityValidated: false,
+    effectObservations: 'unavailable'
+  });
+  return (options = {}) => {
+    if (options.liveFetch === true) throw new TypeError('Fastly Native fixture execution cannot perform live fetches.');
+    const kvStores = {};
+    for (const [logical, physical] of Object.entries(bindings.kv || {})) {
+      kvStores[physical] = { ...kvStores[physical], ...(options.kv && options.kv[logical] || {}) };
+    }
+    const authority = createConditionalKvAuthority();
+    for (const [store, values] of Object.entries(kvStores)) {
+      authority.stores.set(store, new Map());
+      for (const [key, value] of Object.entries(values)) {
+        authority.seed(store, key, Buffer.from(JSON.stringify({ __pulseKv: 1, value })));
+      }
+    }
+    const execution = executeFastlyNativePlatformCapabilities(native, {
+      request: options.request,
+      fixtures: options.fetches,
+      configStore: bindings.configStore,
+      config: options.config,
+      secretStore: bindings.secretStore,
+      secrets: options.secrets,
+      kvStores,
+      conditionalKv: { authority }
+    });
+    const contentType = execution.response.headers.find(([name]) => name.toLowerCase() === 'content-type');
+    const type = String(contentType && contentType[1] || '').toLowerCase();
+    return Object.freeze({
+      response: Object.freeze({
+        ...execution.response,
+        kind: type.includes('application/json') || type.includes('+json') ? 'json' : type.startsWith('text/') ? 'text' : 'response',
+        // Forwarding filters origin metadata into a new response handle, so
+        // its streamed payload remains opaque even though origin is false.
+        // Pre-commit errors use ordinary non-streaming structured responses.
+        bodyClass: execution.response.origin === true
+          || (native.plan.capabilities.includes('request.body.forward') && execution.response.streaming === 1)
+          ? 'opaque' : 'structured'
+      }),
+      // The fixture ABI has hostcall traces, not canonical continuation telemetry.
+      effectCount: null,
+      continuations: Object.freeze([]),
+      resolutionOrder: Object.freeze([]),
+      evidence
+    });
+  };
+}
+
+module.exports = { prepareFastlyNativeExecution };

package/src/toolchain/s3.js

@@ -0,0 +1,26 @@
+'use strict';
+const { normalizeBinding, namePattern } = require('@pulse-compute/s3/provider');
+function normalizeFastlyS3(input = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input) || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) throw new TypeError('Fastly S3 bindings must be a map.');
+  for (const key of Reflect.ownKeys(input)) {
+    const field = Object.getOwnPropertyDescriptor(input, key);
+    if (typeof key !== 'string' || !field.enumerable || !Object.hasOwn(field, 'value')) throw new TypeError('Fastly S3 bindings require data properties.');
+  }
+  return Object.freeze(Object.fromEntries(Object.entries(input).map(([name, value]) => {
+    if (!namePattern.test(name) || !value || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+      || Reflect.ownKeys(value).some((key) => { const field = Object.getOwnPropertyDescriptor(value, key); return typeof key !== 'string' || !field.enumerable || !Object.hasOwn(field, 'value'); })) throw new TypeError('Fastly S3 binding is invalid.');
+    const { backend, ...binding } = value;
+    if (typeof backend !== 'string' || !namePattern.test(backend)) throw new TypeError('Fastly S3 requires a named static backend.');
+    return [name, Object.freeze({ ...normalizeBinding(binding), backend })];
+  })));
+}
+function resolveFastlyS3(effects, input) {
+  const configured = normalizeFastlyS3(input);
+  return Object.freeze(effects.flatMap((effect, index) => {
+    if (!['s3.head', 's3.getText', 's3.putText', 's3.getBody'].includes(effect.kind)) return [];
+    const name = effect.resource && effect.resource.binding;
+    if (!Object.hasOwn(configured, name)) throw new TypeError('The required Fastly S3 binding is missing.');
+    return [Object.freeze({ index, ...configured[name], ...(effect.operation === 'getBody' ? require('@pulse-compute/s3/provider').normalizeBodyOptions(Object.fromEntries(['method', 'range', 'ifNoneMatch'].filter(key => effect.payload?.[key] !== undefined).map(key => [key, effect.payload[key]]))) : {}), contentType: effect.operation === 'putText' ? require('@pulse-compute/s3/provider').normalizePutOptions({ contentType: effect.payload && effect.payload.contentType }).contentType : '' })];
+  }));
+}
+module.exports = { normalizeFastlyS3, resolveFastlyS3 };