@pulse-compute/provider-node 0.0.0 → 1.0.0-beta.2

package/src/javascript/target-support-policy.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const {
+  isJavascriptCoreCapability
+} = require('@pulse-compute/wasm-contracts/project/javascript-core-capabilities');
+
+function decision(id, status, reasonId, owner, required = true) {
+  return Object.freeze({ id, status, required, reasonId, owner });
+}
+
+function classifyNodeJavascriptCapability(id, options = {}) {
+  const capability = String(id);
+  if (['s3.head', 's3.getText', 's3.putText'].includes(capability)) return decision(capability, 'eligible', 'node-s3-bounded-origin-transport', 'provider-node');
+  if (isJavascriptCoreCapability(capability)) {
+    return decision(capability, 'eligible', 'node-router-context-parity', 'provider-node');
+  }
+  if (capability === 'logging' || capability === 'log' || capability.startsWith('log.')) {
+    return decision(capability, 'eligible', 'javascript-logging-runtime', 'runtime');
+  }
+  if (capability === 'request.json' || capability === 'req.json' || capability.startsWith('request.body') || capability.startsWith('req.body')) {
+    return decision(capability, 'eligible', 'javascript-request-body-realization', 'runtime');
+  }
+  if (
+    capability === 'fetch'
+    || capability.startsWith('fetch.')
+    || capability === 'backend-fetch'
+    || capability === 'body'
+    || capability === 'headers'
+    || capability === 'json'
+    || capability === 'opaque.pass-through'
+    || capability === 'result'
+    || capability.startsWith('result.')
+  ) {
+    return decision(capability, 'eligible', 'javascript-fetch-projection-realization', 'runtime');
+  }
+  if (capability === 'clock' || capability === 'timer') {
+    return decision(capability, 'pending', 'javascript-clock-timer-realization-pending', 'runtime');
+  }
+  if (capability === 'time.wall-clock') {
+    return decision(capability, 'eligible', 'node-provider-wall-clock-authority', 'provider-node');
+  }
+  if (
+    capability === 'jwt.verify'
+    || capability === 'jwt.verify.hs256'
+    || capability === 'jwt.verify.es256'
+  ) {
+    return decision(capability, 'eligible', 'node-javascript-jwt-crypto-runtime-builtin', 'provider-node');
+  }
+  if (capability.startsWith('jwt.verify.')) {
+    return decision(capability, 'blocked', 'jwt-crypto-realization-unavailable', 'crypto');
+  }
+  if (capability === 'config.get' || capability === 'secret.get' || capability === 'kv' || capability.startsWith('kv.')) {
+    return options.bindingsRedaction === true
+      ? decision(capability, 'eligible', 'javascript-binding-redaction-implemented', 'provider-node')
+      : decision(capability, 'pending', 'javascript-binding-effect-pending', 'provider-node');
+  }
+  if (capability === 'assets' || capability.startsWith('assets.')) {
+    return decision(capability, 'eligible', 'assets-javascript-realization', 'assets');
+  }
+  if (capability.startsWith('schema.')) {
+    return decision(capability, 'eligible', 'javascript-schema-validation-policy', 'schema-json');
+  }
+  if (capability === 'event.ingress') {
+    return decision(capability, 'eligible', 'node-event-reference-ingress', 'provider-node');
+  }
+  if (capability === 'event.emit') {
+    return decision(capability, 'eligible', 'node-event-reference-acceptance', 'provider-node');
+  }
+  if (capability === 'broadcaster' || capability === 'channel' || capability === 'grip' || capability.startsWith('grip.')) {
+    return options.gripRealized === true
+      ? decision(capability, 'eligible', 'grip-realization-implemented', 'grip')
+      : decision(capability, 'pending', 'grip-javascript-readiness-pending', 'grip');
+  }
+  return decision(capability, 'blocked', 'unknown-javascript-capability-fail-closed', 'compiler');
+}
+
+function classifyNodeJavascriptProviderRequirement(id, compilerCapabilities, options = {}) {
+  const requirement = String(id);
+  if (['s3.head', 's3.getText', 's3.putText'].includes(requirement)) return decision(requirement, 'eligible', 'node-s3-bounded-origin-transport', 'provider-node');
+  if (requirement === 'request') {
+    const bodyRequired = compilerCapabilities.some((entry) => entry === 'request.json' || entry.startsWith('request.body'));
+    return bodyRequired
+      ? decision(requirement, 'eligible', 'javascript-request-body-realization', 'runtime')
+      : decision(requirement, 'eligible', 'node-request-adapter-and-body-text', 'provider-node');
+  }
+  if (['response.json', 'response.text', 'response.custom'].includes(requirement)) {
+    return decision(requirement, 'eligible', 'node-response-ownership', 'provider-node');
+  }
+  if (requirement === 'fetch' || requirement === 'opaque.pass-through' || ['body', 'headers', 'result'].includes(requirement)) {
+    return decision(requirement, 'eligible', 'javascript-fetch-projection-realization', 'runtime');
+  }
+  if (['config.get', 'secret.get', 'kv.get', 'kv.put', 'kv.getVersioned', 'kv.insertIfAbsent', 'kv.compareAndSwap'].includes(requirement)) {
+    return options.bindingsRedaction === true
+      ? decision(requirement, 'eligible', 'javascript-binding-redaction-implemented', 'provider-node')
+      : decision(requirement, 'pending', 'javascript-binding-effect-pending', 'provider-node');
+  }
+  if (requirement === 'assets' || requirement.startsWith('assets.')) {
+    return decision(requirement, 'eligible', 'assets-javascript-realization', 'assets');
+  }
+  if (requirement === 'clock') {
+    return decision(requirement, 'pending', 'javascript-clock-timer-realization-pending', 'runtime');
+  }
+  if (requirement === 'time.wall-clock') {
+    return decision(requirement, 'eligible', 'node-provider-wall-clock-authority', 'provider-node');
+  }
+  if (
+    requirement === 'jwt.verify'
+    || requirement === 'jwt.verify.hs256'
+    || requirement === 'jwt.verify.es256'
+  ) {
+    return decision(requirement, 'eligible', 'node-javascript-jwt-crypto-runtime-builtin', 'provider-node');
+  }
+  if (requirement.startsWith('jwt.verify.')) {
+    return decision(requirement, 'blocked', 'jwt-crypto-realization-unavailable', 'crypto');
+  }
+  if (requirement.startsWith('schema.')) {
+    return decision(requirement, 'eligible', 'javascript-schema-validation-policy', 'schema-json');
+  }
+  if (requirement === 'event.ingress') {
+    return decision(requirement, 'eligible', 'node-event-reference-ingress', 'provider-node');
+  }
+  if (requirement === 'event.emit') {
+    return decision(requirement, 'eligible', 'node-event-reference-acceptance', 'provider-node');
+  }
+  if (['broadcaster', 'channel'].includes(requirement) || requirement === 'grip' || requirement.startsWith('grip.')) {
+    return options.gripRealized === true
+      ? decision(requirement, 'eligible', 'grip-realization-implemented', 'grip')
+      : decision(requirement, 'pending', 'grip-javascript-readiness-pending', 'grip');
+  }
+  return decision(requirement, 'blocked', 'unknown-provider-requirement-fail-closed', 'compiler');
+}
+
+module.exports = Object.freeze({
+  classifyNodeJavascriptCapability,
+  classifyNodeJavascriptProviderRequirement
+});

package/src/javascript/target.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { normalizeJavascriptTargetDescriptor } = require('@pulse-compute/wasm-contracts/project/javascript-application');
+const { defineCryptoTargetCapabilities } = require('@pulse-compute/wasm-contracts/crypto/contracts');
+
+const NODE_JAVASCRIPT_TARGET_DESCRIPTOR = normalizeJavascriptTargetDescriptor({
+  provider: 'node', targetId: 'node-javascript', status: 'source-packaging-ready',
+  hostBridge: true, applicationLoader: true, requestAdapter: true, lifecycle: true,
+  capabilities: {
+    version: 'pulse.javascript-capability-envelope.v1',
+    provider: 'node',
+    status: 'request-and-event-lifecycle-ready',
+    core: { request: true, response: true, state: true, eventIngress: true },
+    effects: { fetch: true, config: true, secret: true, kv: true, eventEmit: true },
+    events: { ingress: true, emit: true, automaticLoopback: false },
+    packages: []
+  },
+  crypto: defineCryptoTargetCapabilities({
+    target: 'javascript',
+    algorithms: [...['SHA-256', 'HMAC-SHA256'].map((algorithm) => ({ algorithm, realization: 'runtime-builtin', implemented: true, status: 'implemented-o3' })), {
+      algorithm: 'HS256',
+      realization: 'runtime-builtin',
+      implemented: true,
+      status: 'implemented-c2'
+    }, {
+      algorithm: 'ES256',
+      realization: 'runtime-builtin',
+      implemented: true,
+      status: 'implemented-g3'
+    }]
+  }),
+  commands: { compile: true, inspect: true, doctor: true, build: true, test: true, dev: true }
+});
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_TARGET_DESCRIPTOR
+});

package/src/javascript/test-runtime.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const runtimeHost = require('@pulse-compute/runtime/host');
+const { executeNodeJavascriptApplication } = require('./runtime-host.js');
+const { createNodeJavascriptFixtureFetch } = require('./fetch-adapter.js');
+
+const NODE_JAVASCRIPT_TEST_RUNTIME_VERSION = 'pulse.node-javascript-test-runtime.v1';
+
+function createTestRequest(input = {}) {
+  const method = String(input.method || 'GET').toUpperCase();
+  const headerPairs = Object.freeze((input.headers || []).map(([name, value]) => Object.freeze([String(name), String(value)])));
+  const headers = new Headers();
+  for (const [name, value] of headerPairs) headers.append(name, value);
+  const init = { method, headers };
+  if (method !== 'GET' && method !== 'HEAD' && input.body !== undefined) {
+    init.body = typeof input.body === 'string' || Buffer.isBuffer(input.body) || input.body instanceof Uint8Array
+      ? input.body
+      : JSON.stringify(input.body);
+  }
+  return Object.freeze({
+    request: new Request(input.url || `http://127.0.0.1${String(input.path || '/')}`, init),
+    headerPairs
+  });
+}
+
+function responseKind(response) {
+  const contentType = String(response.headers.get('content-type') || '').toLowerCase();
+  if (contentType.includes('application/json') || contentType.includes('+json')) return 'json';
+  if (contentType.startsWith('text/')) return 'text';
+  return 'response';
+}
+
+async function executeNodeJavascriptTestCase(application, testCase, options = {}) {
+  const adapted = createTestRequest(testCase.request);
+  let effectSummary;
+  const fixtureFetch = options.fetchImplementation || createNodeJavascriptFixtureFetch(
+    testCase.fetches || {},
+    options.networkFetch === true ? globalThis.fetch : undefined
+  );
+  const gripFixtureFetch = options.gripFetchImplementation || createNodeJavascriptFixtureFetch(
+    testCase.fetches || {},
+    options.networkFetch === true ? globalThis.fetch : undefined,
+    { rawResponse: true }
+  );
+  const response = await executeNodeJavascriptApplication(application, adapted.request, {
+    capabilities: options.capabilities,
+    effectAdapter: options.effectAdapter,
+    fetchImplementation: fixtureFetch,
+    gripFetchImplementation: gripFixtureFetch,
+    grip: testCase.grip || options.grip,
+    gripBroadcast: options.gripBroadcast,
+    jwtCaptureWallClock: options.jwtCaptureWallClock,
+    config: testCase.config || {},
+    secrets: testCase.secrets || {},
+    s3: options.s3 || options.bindings && options.bindings.s3,
+    kv: testCase.kv || {},
+    application: options.application,
+    requestHeaders: adapted.headerPairs,
+    maxEffects: options.maxEffects,
+    maxRequestBodyBytes: options.maxRequestBodyBytes ?? options.maxBodyBytes ?? testCase.maxBodyBytes,
+    maxFetchBodyBytes: options.maxFetchBodyBytes ?? testCase.maxBodyBytes,
+    maxStructuredBodyBytes: options.maxStructuredBodyBytes,
+    maxBindingNameBytes: options.maxBindingNameBytes,
+    maxBindingValueBytes: options.maxBindingValueBytes,
+    maxKvNamespaceBytes: options.maxKvNamespaceBytes,
+    maxKvKeyBytes: options.maxKvKeyBytes,
+    maxKvValueBytes: options.maxKvValueBytes,
+    maxKvValueDepth: options.maxKvValueDepth,
+    maxKvValueEntries: options.maxKvValueEntries,
+    schemaCodecs: options.schemaCodecs,
+    strict: options.strict === true,
+    provider: options.provider || 'node',
+    reporting: options.reporting,
+    log: options.log,
+    onLogObservation: options.onLogObservation,
+    onJsonTrace: options.onJsonTrace,
+    onEffectObservation: options.onEffectObservation,
+    onEffectSummary(summary) {
+      effectSummary = summary;
+      if (typeof options.onEffectSummary === 'function') options.onEffectSummary(summary);
+    }
+  });
+  const method = String(testCase.request && testCase.request.method || 'GET').toUpperCase();
+  const body = method === 'HEAD' ? '' : Buffer.from(await response.arrayBuffer()).toString('utf8');
+  return Object.freeze({
+    version: NODE_JAVASCRIPT_TEST_RUNTIME_VERSION,
+    response: Object.freeze({
+      status: response.status,
+      kind: responseKind(response),
+      bodyClass: runtimeHost.responseBodyClass(response),
+      headers: runtimeHost.responseHeaderPairs(response),
+      body
+    }),
+    effectCount: effectSummary ? effectSummary.ownedEffectCount : 0,
+    externalEffectCount: effectSummary ? effectSummary.effectCount : 0,
+    localEffectCount: effectSummary ? effectSummary.localEffectCount : 0,
+    continuations: Object.freeze((effectSummary && effectSummary.groups || []).map((group) => Object.freeze({
+      id: group.id,
+      kind: 'parallel',
+      effectIds: group.effectIds,
+      keys: group.keys
+    }))),
+    resolutionOrder: effectSummary ? effectSummary.resolutionOrder : Object.freeze([])
+  });
+}
+
+module.exports = Object.freeze({
+  NODE_JAVASCRIPT_TEST_RUNTIME_VERSION,
+  createTestRequest,
+  executeNodeJavascriptTestCase,
+  responseKind
+});

package/src/native/target.js

@@ -0,0 +1,78 @@
+'use strict';
+const { defineFinalWasmPolicy, FINAL_WASM_POLICY_VERSION } = require('@pulse-compute/wasm-contracts/provider/final-wasm-policy');
+const { defineCryptoTargetCapabilities } = require('@pulse-compute/wasm-contracts/crypto/contracts');
+const nativeRuntime = require('@pulse-compute/wasm-contracts/handler/canonical-native-runtime');
+const packageManifest = require('../../package.json');
+const { NODE_NATIVE_TARGET_CAPABILITIES } = require('../capabilities.js');
+
+const nodeFinalWasmPolicy = defineFinalWasmPolicy({
+  version: FINAL_WASM_POLICY_VERSION,
+  descriptorOwner: packageManifest.name,
+  toolchainVersion: 'pulse.provider-toolchain.v1',
+  descriptorIdentity: 'node-native-host',
+  permittedImports: [
+    ...nativeRuntime.CANONICAL_NATIVE_IMPORT_NAMES.map((name) => ({ module: 'pulse_host', name, kind: 'function' })),
+    ...nativeRuntime.CANONICAL_NATIVE_ALLOWED_ENV_IMPORTS.map((name) => ({ module: 'env', name, kind: 'function' }))
+  ],
+  requiredExports: nativeRuntime.CANONICAL_NATIVE_EXPORTS.map(([name, second]) => ({
+    name,
+    kind: second === 'memory' ? 'memory' : 'function'
+  }))
+});
+
+const NODE_NATIVE_TARGET_DESCRIPTOR = Object.freeze({
+  version: 'pulse.provider-target-descriptor.v1',
+  id: 'node-native-host',
+  provider: 'node',
+  mode: 'native',
+  runtimeClass: 'native',
+  status: 'supported',
+  capabilities: NODE_NATIVE_TARGET_CAPABILITIES,
+  keyTypes: Object.freeze(['secret', 'jwk', 'jwks']),
+  realizations: Object.freeze([
+    Object.freeze({
+      kind: 'crypto-composed',
+      realization: 'guest-source:pulse-hmac-as',
+      implementation: 'pulse-hmac-as.v1',
+      algorithms: Object.freeze(['HS256']),
+      keyTypes: Object.freeze(['secret']),
+      implemented: true,
+      status: 'implemented-d3',
+      semanticOwner: '@pulse-compute/crypto',
+      guestUnitRequired: false,
+      portable: true,
+      automaticFallback: false
+    }),
+    Object.freeze({
+      kind: 'crypto-composed',
+      realization: 'guest-linked:pulse-es256-rustcrypto-p256',
+      implementation: 'rustcrypto.p256-0.13.2.ecdsa-0.16.9.sha2-0.10.9.v1',
+      algorithms: Object.freeze(['ES256']),
+      keyTypes: Object.freeze(['jwk', 'jwks']),
+      implemented: true,
+      status: 'implemented-g3',
+      semanticOwner: '@pulse-compute/crypto',
+      guestUnitRequired: true,
+      portable: true,
+      automaticFallback: false
+    })
+  ]),
+  automaticFallback: false,
+  crypto: defineCryptoTargetCapabilities({
+    target: 'native',
+    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,
+      status: 'implemented-c3'
+    }, {
+      algorithm: 'ES256',
+      realization: 'guest-linked:pulse-es256-rustcrypto-p256',
+      implemented: true,
+      status: 'implemented-g3'
+    }]
+  }),
+  finalWasmPolicy: nodeFinalWasmPolicy
+});
+
+module.exports = Object.freeze({ NODE_NATIVE_TARGET_DESCRIPTOR });