@pulse-compute/wasm-contracts 1.0.0-beta.5 → 1.0.0-beta.6

package/README.md

@@ -7,9 +7,9 @@
 > **Supported entry points:** `@pulse-compute/wasm-contracts/provider/toolchain`<br>
 > **Stability:** The provider toolchain contract is versioned and supported for the Beta; other protocol and proof interfaces remain internal.<br>
 > **npm:** [`@pulse-compute/wasm-contracts`](https://www.npmjs.com/package/@pulse-compute/wasm-contracts)<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.5/packages/implementation-packages/)
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.6/packages/implementation-packages/)
 >
-> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.5` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.6` package policy.
 <!-- pulse-package-status:end -->
 
 This package owns stable data contracts shared by the compiler, runtime, and providers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulse-compute/wasm-contracts",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.6",
   "license": "Apache-2.0",
   "engines": {
     "node": "^22.14.0 || ^24.0.0"
@@ -126,7 +126,7 @@
     "url": "git+https://github.com/pulse-compute/pulse.git",
     "directory": "wasm/packages/contracts"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.5/packages/implementation-packages/",
+  "homepage": "https://pulsecompute.io/v1.0.0-beta.6/packages/implementation-packages/",
   "bugs": {
     "url": "https://github.com/pulse-compute/pulse/issues"
   }

package/src/assets/contracts.js

@@ -37,7 +37,7 @@ const ASSETS_INITIAL_PROVIDER_TARGETS = Object.freeze(['node', 'fastly']);
 
 const ASSETS_PAYLOAD_MODE_STATUSES = LOWERABLE_LIBRARY_PAYLOAD_MODE_STATUSES;
 
-const ASSETS_SUPPORTED_BODY_KINDS = Object.freeze(['text-response-body']);
+const ASSETS_SUPPORTED_BODY_KINDS = Object.freeze(['text-response-body', 'embedded-blob-response']);
 const ASSETS_LOWERING_PLAN_ONLY_BODY_KINDS = Object.freeze(['stream-pass-through-response']);
 const ASSETS_RESERVED_BODY_KINDS = Object.freeze(['binary-buffer']);
 const ASSETS_UNSUPPORTED_BODY_KINDS = Object.freeze(['json-response-body']);
@@ -78,6 +78,11 @@ const ASSETS_DIAGNOSTIC_CODES = Object.freeze({
 });
 
 const ASSETS_PAYLOAD_MODE_CLASSIFICATION = Object.freeze({
+  embeddedBlobResponse: Object.freeze({
+    mode: 'embedded-blob-response', status: 'implemented-now', hostResultKind: 'opaque-response',
+    hostCapabilities: Object.freeze(['assets', 'result']), owner: '@pulse-compute/assets',
+    notes: 'Native-only, compile-time admitted embeddedManifest literal; bounded selected bytes remain provider-owned.'
+  }),
   textResponseBody: Object.freeze({
     mode: 'text-response-body',
     status: 'implemented-now',
@@ -249,6 +254,7 @@ function assetsProtocolExtension() {
 }
 
 module.exports = {
+  ...require('./embedded.js'),
   ASSETS_CONTRACT_VERSION,
   ASSETS_HOST_ABI_VERSION,
   ASSETS_PROVIDER_CONFIG_VERSION,

package/src/assets/embedded.as.ts

@@ -0,0 +1,48 @@
+// Native counterpart of embeddedAssetResponse; inputs are admitted by the Assets lowerer.
+class __PulseEmbeddedSelection {
+  status: i32 = 200; start: i32 = 0; end: i32 = -1; contentRange: string = '';
+}
+function __pulse_embedded_decimal(value: string): f64 {
+  if (!value.length || (value.length > 1 && value.charCodeAt(0) == 48)) return -1;
+  let output: f64 = 0;
+  for (let i = 0; i < value.length; i++) {
+    const digit = value.charCodeAt(i) - 48; if (digit < 0 || digit > 9) return -1;
+    output = output * 10 + digit; if (output > 9007199254740991) return -1;
+  }
+  return output;
+}
+function __pulse_embedded_selection(length: i32, method: string, etag: string, validator: string | null, range: string | null, ifRange: string | null): __PulseEmbeddedSelection {
+  const output = new __PulseEmbeddedSelection(); output.end = length - 1;
+  if (length < 0) { output.status = 404; return output; }
+  if (validator !== null) {
+    let tag = validator;
+    if (tag.startsWith('W/')) tag = tag.slice(2);
+    if (validator != '*') {
+      if (tag.length < 2 || tag.charAt(0) != '"' || tag.charAt(tag.length - 1) != '"') { output.status = 400; return output; }
+      for (let i = 1; i < tag.length - 1; i++) if (tag.charCodeAt(i) < 33 || tag.charCodeAt(i) > 126 || tag.charCodeAt(i) == 34) { output.status = 400; return output; }
+    }
+    if (validator == '*' || tag == etag) { output.status = 304; return output; }
+  }
+  if (method == 'GET' && range !== null && (ifRange === null || ifRange == etag)) {
+    if (!range.startsWith('bytes=')) { output.status = 400; return output; }
+    const parts = range.slice(6).split('-');
+    if (parts.length != 2) { output.status = 400; return output; }
+    const start = __pulse_embedded_decimal(parts[0]), end = __pulse_embedded_decimal(parts[1]);
+    if (start < 0 || end < start) { output.status = 400; return output; }
+    if (start >= length) { output.status = 416; output.contentRange = 'bytes */' + length.toString(); return output; }
+    output.start = i32(start); output.end = i32(Math.min(end, f64(length - 1))); output.status = 206;
+    output.contentRange = 'bytes ' + output.start.toString() + '-' + output.end.toString() + '/' + length.toString();
+  }
+  return output;
+}
+function __pulse_embedded_bytes(data: string, start: i32, end: i32): Uint8Array {
+  const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  const output = new Uint8Array(max<i32>(0, end - start + 1));
+  // Decode only the selected interval, without a full-file temporary copy.
+  for (let index = start; index <= end; index++) {
+    const group = (index / 3) * 4, part = index % 3;
+    const a = alphabet.indexOf(data.charAt(group + part)), b = alphabet.indexOf(data.charAt(group + part + 1));
+    output[index - start] = u8(part == 0 ? (a << 2) | (b >> 4) : part == 1 ? (a << 4) | (b >> 2) : (a << 6) | b);
+  }
+  return output;
+}

package/src/assets/embedded.js

@@ -0,0 +1,63 @@
+'use strict';
+// Compile-time admission and host response policy for explicitly embedded bytes.
+const LIMITS = Object.freeze({ files:256, fileBytes:262144, totalBytes:1048576, pathBytes:1024, serializedBytes:2097152 });
+const VERSION = 'pulse.embedded-assets.v1';
+function fail() { throw new TypeError('Invalid or oversized embedded asset manifest.'); }
+function fields(value, names) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length !== names.length || names.some(name=>!Object.hasOwn(value,name))) fail();
+}
+function assetPath(value) {
+  if (typeof value !== 'string' || !value.isWellFormed() || !value.startsWith('/') || value === '/' || Buffer.byteLength(value)>LIMITS.pathBytes
+    || /[\\%?#\u0000-\u001f\u007f-\u009f]/u.test(value) || value.slice(1).split('/').some(p=>!p||p==='.'||p==='..')) fail();
+  return value;
+}
+function selectEmbeddedAsset(serialized, key) {
+  if (typeof serialized !== 'string' || serialized.length > LIMITS.serializedBytes || Buffer.byteLength(serialized)>LIMITS.serializedBytes) fail();
+  let manifest; try { manifest=JSON.parse(serialized); } catch { fail(); }
+  // Canonical serialization rejects duplicate fields and ambiguous encodings.
+  if (JSON.stringify(manifest)!==serialized) fail();
+  fields(manifest,['version','id','byteLength','files']);
+  if (manifest.version!==VERSION || !Array.isArray(manifest.files) || manifest.files.length>LIMITS.files) fail();
+  const hash = value=>require('node:crypto').createHash('sha256').update(value).digest('hex');
+  let total=0,previous='';
+  for (const file of manifest.files) {
+    fields(file,['path','data','byteLength','sha256','contentType']);
+    const path=assetPath(file.path);
+    if (path<=previous || !Number.isInteger(file.byteLength) || file.byteLength<0 || file.byteLength>LIMITS.fileBytes
+      || typeof file.contentType!=='string' || !/^[\x20-\x7e]{1,128}$/.test(file.contentType) || file.contentType.trim()!==file.contentType
+      || typeof file.data!=='string' || file.data.length!==4*Math.ceil(file.byteLength/3)) fail();
+    previous=path; total+=file.byteLength; if(total>LIMITS.totalBytes) fail();
+    const bytes=Buffer.from(file.data,'base64');
+    if(bytes.length!==file.byteLength || bytes.toString('base64')!==file.data || hash(bytes)!==file.sha256) fail();
+  }
+  if(manifest.byteLength!==total || hash(JSON.stringify([VERSION,manifest.files.map(f=>[f.path,f.contentType,f.byteLength,f.sha256])]))!==manifest.id) fail();
+  assetPath(key);
+  const file=manifest.files.find(f=>f.path===key);
+  return Object.freeze({embeddedId:manifest.id,embeddedFound:!!file,embeddedData:file?.data??'',embeddedLength:file?.byteLength??0,embeddedType:file?.contentType??'',embeddedEtag:file?`"${file.sha256}"`:''});
+}
+function embeddedAssetResponse(payload, requestHeaders) {
+  const headers=new Headers(requestHeaders), output=new Headers();
+  const length=payload.embeddedLength;
+  if(!payload.embeddedFound) return {status:404,headers:output,bytes:null};
+  if(!Number.isInteger(length)||length<0||length>LIMITS.fileBytes||typeof payload.embeddedData!=='string'||payload.embeddedData.length!==4*Math.ceil(length/3)) fail();
+  output.set('content-type',payload.embeddedType); output.set('etag',payload.embeddedEtag); output.set('accept-ranges','bytes');
+  const validator=headers.get('if-none-match');
+  if(validator!==null) {
+    if(!/^(?:\*|(?:W\/)?"[\x21\x23-\x7e]*")$/.test(validator)) return {status:400,headers:new Headers(),bytes:null};
+    if(validator==='*'||validator.replace(/^W\//,'')===payload.embeddedEtag) return {status:304,headers:output,bytes:null};
+  }
+  let start=0,end=length-1,status=200;
+  const range=headers.get('range'), ifRange=headers.get('if-range');
+  if(payload.method==='GET'&&range!==null&&(ifRange===null||ifRange===payload.embeddedEtag)) {
+    const match=/^bytes=(0|[1-9][0-9]*)-(0|[1-9][0-9]*)$/.exec(range);
+    if(!match||!Number.isSafeInteger(Number(match[2]))||Number(match[1])>Number(match[2])) return {status:400,headers:new Headers(),bytes:null};
+    start=Number(match[1]);end=Math.min(Number(match[2]),end);
+    if(start>=length){output.set('content-range',`bytes */${length}`);return {status:416,headers:output,bytes:null};}
+    status=206;output.set('content-range',`bytes ${start}-${end}/${length}`);
+  }
+  output.set('content-length',String(Math.max(0,end-start+1)));
+  const bytes=payload.method==='HEAD'?null:Buffer.from(payload.embeddedData,'base64').subarray(start,end+1);
+  return {status,headers:output,bytes};
+}
+function embeddedNativeSource() { return require('node:fs').readFileSync(require('node:path').join(__dirname,'embedded.as.ts'),'utf8'); }
+module.exports={embeddedNativeSource,EMBEDDED_ASSET_NATIVE_LIMITS:LIMITS,selectEmbeddedAsset,embeddedAssetResponse};

package/src/crypto/contracts.js

@@ -23,8 +23,15 @@ const CRYPTO_VERIFICATION_STATUSES = Object.freeze([
   'realization-failure'
 ]);
 
-const CRYPTO_ALGORITHMS = Object.freeze(['HS256', 'ES256', 'SHA-256', 'HMAC-SHA256']);
+const CRYPTO_RS256_RUNTIME_BUILTIN_IMPLEMENTATION = 'webcrypto.subtle.rsassa-pkcs1-v1_5-sha-256.v1';
+const CRYPTO_RS256_GUEST_LINKED_REALIZATION = 'guest-linked:pulse-rs256-bearssl-i31';
+const CRYPTO_RS256_GUEST_LINKED_IMPLEMENTATION = 'bearssl.0.6.rsa-i31.sha256.v1';
+const CRYPTO_ALGORITHMS = Object.freeze(['HS256', 'ES256', 'RS256', 'SHA-256', 'HMAC-SHA256']);
 const CRYPTO_REALIZATIONS = Object.freeze([
+  { id: 'runtime-builtin', kind: 'runtime-builtin', algorithm: 'RS256', targets: ['javascript'], implementation: CRYPTO_RS256_RUNTIME_BUILTIN_IMPLEMENTATION },
+  { id: CRYPTO_RS256_GUEST_LINKED_REALIZATION, kind: 'guest-linked', algorithm: 'RS256', targets: ['native'],
+    backend: 'pulse-rs256-bearssl-i31', implementation: CRYPTO_RS256_GUEST_LINKED_IMPLEMENTATION,
+    source: { package: '@pulse-compute/crypto', export: './pulsewasm-native', contractVersion: 'pulse.guest-unit-contribution.v1', contribution: 'pulseEs256GuestUnit' } },
   ...['SHA-256', 'HMAC-SHA256'].map((algorithm) => Object.freeze({
     id: 'runtime-builtin', kind: 'runtime-builtin', algorithm, targets: Object.freeze(['javascript']),
     implementation: algorithm === 'SHA-256' ? 'webcrypto.subtle.sha-256-bytes.v1' : 'webcrypto.subtle.hmac-sha-256-bytes.v1'
@@ -148,7 +155,7 @@ const CRYPTO_ES256_CONTRACT = deepFreeze({
     unitId: 'pulse.crypto.es256.rustcrypto-p256.v1',
     module: 'pulse_crypto_es256',
     owner: '@pulse-compute/crypto',
-    abi: 'pulse.crypto.es256.verify.v1',
+    abi: 'pulse.crypto.es256-rs256.verify-and-sign.v3',
     export: {
       name: 'pulse_crypto_es256_verify',
       parameters: ['i32', 'i32'],
@@ -594,7 +601,7 @@ function planCryptoRealizations(input = {}) {
     const requirement = requirements.algorithms.find((entry) => entry.algorithm === configured.algorithm);
     return {
       algorithm: configured.algorithm,
-      primitive: configured.algorithm === 'ES256'
+      primitive: configured.algorithm === 'RS256' ? Object.freeze({ kind: 'rsa-pkcs1-v1_5', hash: 'SHA-256' }) : configured.algorithm === 'ES256'
         ? Object.freeze({ kind: 'ecdsa', curve: 'P-256', hash: 'SHA-256' })
         : Object.freeze({ kind: configured.algorithm === 'SHA-256' ? 'digest' : 'hmac', hash: 'SHA-256' }),
       requestedBy: requirement ? requirement.requestedBy : Object.freeze([]),
@@ -623,6 +630,7 @@ function planCryptoRealizations(input = {}) {
 }
 
 module.exports = Object.freeze({
+  CRYPTO_RS256_RUNTIME_BUILTIN_IMPLEMENTATION, CRYPTO_RS256_GUEST_LINKED_REALIZATION, CRYPTO_RS256_GUEST_LINKED_IMPLEMENTATION,
   CRYPTO_CONFIGURATION_VERSION,
   CRYPTO_TARGET_CAPABILITIES_VERSION,
   CRYPTO_REQUIREMENTS_VERSION,

package/src/definitions/router-api.js

@@ -41,9 +41,10 @@ const ROUTER_API_DEFINITIONS = Object.freeze([
     name: 'mount',
     kind: 'mount',
     opKind: 'mount',
-    allowedArities: Object.freeze([2]),
+    allowedArities: Object.freeze([2, 3]),
     signatures: Object.freeze([
-      Object.freeze({ arity: 2, pathArg: 0, routerArg: 1 })
+      Object.freeze({ arity: 2, pathArg: 0, routerArg: 1 }),
+      Object.freeze({ arity: 3, pathArg: 0, routerArg: 1, eligibilityArg: 2 })
     ]),
     pathPolicy: 'mount-static'
   }),

package/src/diagnostics/codes.js

@@ -10,6 +10,7 @@ const DIAGNOSTIC_CODES = Object.freeze({
   UNSUPPORTED_HANDLER: 'PULSEWASM_UNSUPPORTED_HANDLER',
   UNSUPPORTED_CHANNEL: 'PULSEWASM_UNSUPPORTED_CHANNEL',
   UNSUPPORTED_LIFECYCLE: 'PULSEWASM_UNSUPPORTED_LIFECYCLE',
+  UNSUPPORTED_MOUNT_ELIGIBILITY: 'PULSEWASM_UNSUPPORTED_MOUNT_ELIGIBILITY',
   UNSUPPORTED_MOUNT_TARGET: 'PULSEWASM_UNSUPPORTED_MOUNT_TARGET',
   COMPUTED_METHOD: 'PULSEWASM_COMPUTED_METHOD',
   DYNAMIC_ROUTE_REGISTRATION: 'PULSEWASM_DYNAMIC_ROUTE_REGISTRATION',

package/src/diagnostics.js

@@ -2,7 +2,7 @@
 
 const path = require('node:path');
 
-const PACKAGE_VERSION = 'pulsewasm-route-extractor@1.0.0-beta.5';
+const PACKAGE_VERSION = 'pulsewasm-route-extractor@1.0.0-beta.6';
 const DIAGNOSTICS_VERSION = 'pulsewasm.diagnostics.v1';
 
 function stableFileName(fileName, cwd) {

package/src/entities/contracts.d.ts

@@ -71,6 +71,7 @@ declare const contracts: {
   normalizeStaticMetadata(value: unknown, limits?: EntitiesLimits): Readonly<Record<string, unknown>> | undefined;
   normalizeEntityDeclaration(input: unknown, limits?: EntitiesLimits): NormalizedEntityDeclaration;
   normalizeHandler<T extends Function>(handler: T): T;
+  nativeEntitySchemaIssue(schema: Readonly<{ id: string; root?: unknown; jsonLimits?: unknown }>): Readonly<{ schemaId: string; reason: string; path: string; kind?: string }> | null;
   normalizeHandlerReference(input: unknown): Readonly<Record<string, string>>;
   normalizeJsonRpcAdapterOptions(input?: Readonly<{ namedParamsOnly?: true; acceptEmptyObjectForNoInput?: boolean }>): Readonly<{
     namedParamsOnly: true;

package/src/entities/contracts.js

@@ -98,6 +98,26 @@ function normalizeEntityPlan(input) {
   return Object.freeze({ ...normalized, planHash: sha256Hex(stableStringify(normalized)) });
 }
 
+// One capability decision shared by catalog inspection and Native source
+// generation. Closed typed nesting is implemented; dynamic JSON and explicit
+// admission policies must never be silently projected or ignored.
+function nativeEntitySchemaIssue(schema) {
+  if (schema.jsonLimits) return Object.freeze({ schemaId: schema.id, reason: 'json-admission-not-realized', path: 'root' });
+  function visit(node, path) {
+    if (!node) return null; // Declaration-only compiler passes have no schema IR.
+    if (node.additionalProperties) return { schemaId: schema.id, reason: 'open-object-not-realized', path };
+    if (['scalar-record', 'json-value', 'json-object'].includes(node.kind)) return { schemaId: schema.id, reason: 'dynamic-json-not-realized', path, kind: node.kind };
+    if (node.kind === 'nullable') return visit(node.value, path + '.value');
+    if (node.kind === 'array') return visit(node.element, path + '[]');
+    if (node.kind === 'object') {
+      for (const field of node.fields) { const issue = visit(field.value, path + '.' + field.name); if (issue) return issue; }
+    }
+    return null;
+  }
+  const issue = visit(schema.root, 'root');
+  return issue ? Object.freeze(issue) : null;
+}
+
 module.exports = Object.freeze({
   ...runtime,
   ENTITIES_PACKAGE_VERSION,
@@ -116,6 +136,7 @@ module.exports = Object.freeze({
   ENTITIES_PACKAGE_INTRINSIC_VERSION,
   ENTITIES_PUBLIC_SYMBOLS,
   ENTITIES_PACKAGE_INTRINSICS,
+  nativeEntitySchemaIssue,
   normalizeHandlerReference,
   normalizeEntityRegistry,
   normalizeEntityPlan

package/src/handler/canonical-native-plan.js

@@ -1,9 +1,31 @@
 'use strict';
 
-const CANONICAL_NATIVE_PLAN_VERSION = 'pulse.canonical-native-plan.v2';
+const CANONICAL_NATIVE_PLAN_VERSION = 'pulse.canonical-native-plan.v9';
+const CANONICAL_NATIVE_PURE_LOOP_CALL_VERSION = 'pulse.bounded-pure-loop-call.v1';
+const CANONICAL_NATIVE_TYPED_KV_BORROW_VERSION = 'pulse.typed-kv-borrow.v1';
+const CANONICAL_NATIVE_PURE_BORROW_VERSION = 'pulse.pure-borrow.v1';
+const CANONICAL_NATIVE_PURE_HELPER_VERSION = 'pulse.canonical-native-pure-helper.v2';
+const CANONICAL_NATIVE_HANDLER_BODY_VERSION = 'pulse.canonical-native-handler-body.v1';
+const CANONICAL_NATIVE_STAGE_CONTRACT = Object.freeze({
+  version: 'pulse.canonical-native-stage.v1',
+  maxEffectSites: 64,
+  outputs: Object.freeze(['response', 'next', 'error', 'suspend', 'failure']),
+  frame: Object.freeze({ lifetime: 'invocation', reset: 'stage-entry', suspension: 'retain', nesting: false })
+});
 const CANONICAL_NATIVE_PLAN_HASH_ALGORITHM = 'sha256';
 const CANONICAL_NATIVE_PLAN_OWNERSHIP_VERSION = 'pulse.canonical-native-ownership.v1';
 const CANONICAL_PURE_LOOP_LIMITS = Object.freeze({ maxIterations: 1024, maxNestedIterations: 65536 });
+const CANONICAL_READ_LOOP_CONTRACT = Object.freeze({
+  version: 'pulse.bounded-read-loop.v1',
+  maxIterations: 64,
+  maxNestedIterations: CANONICAL_PURE_LOOP_LIMITS.maxNestedIterations,
+  effectKinds: Object.freeze(['s3.getText', 'kv.getVersioned', 'crypto.digestText', 'output.write', 'output.readTextChunk']),
+  valueIntrinsics: Object.freeze(['schema.decode.text', 'schema.encode.text', 'response.text', 'response.json', 'response.custom']),
+  nestedEffects: false,
+  helperCallVersion: 'pulse.bounded-read-loop-helper.v1',
+  continueTarget: 'increment',
+  breakTarget: 'exit'
+});
 
 const CANONICAL_NATIVE_STATEMENT_KINDS = Object.freeze([
   'local',
@@ -11,13 +33,18 @@ const CANONICAL_NATIVE_STATEMENT_KINDS = Object.freeze([
   'effect-group',
   'if',
   'pure-loop',
+  'read-loop',
   'break',
   'continue',
   'return',
+  'handler-call',
+  'helper-call',
+  'stage-call',
   'expression'
 ]);
 
 const CANONICAL_NATIVE_EXPRESSION_KINDS = Object.freeze([
+  'pure-helper-call',
   'literal',
   'undefined',
   'local',
@@ -46,8 +73,11 @@ const CANONICAL_NATIVE_CONTEXT_READS = Object.freeze([
 ]);
 
 const CANONICAL_NATIVE_INTRINSICS = Object.freeze([
+  'package.application',
   'request.header',
   'request.text',
+  'request.body.forward-marker',
+  'response.output.close',
   'request.json',
   'response.json',
   'schema.encode.text',
@@ -124,7 +154,23 @@ const CANONICAL_NATIVE_PLAN_POLICY = Object.freeze({
   javascriptRuntime: false,
   promiseSemantics: false,
   asyncify: false,
-  controlFlow: 'structured statements, if/else, and literal-capped pure for loops; no effect iteration',
+  controlFlow: 'structured statements, if/else, literal-capped pure for loops and non-nested bounded sequential read loops',
+  handlerBodies: Object.freeze({
+    version: CANONICAL_NATIVE_HANDLER_BODY_VERSION,
+    family: 'terminal HTTP route bodies without next transfer',
+    calls: 'one static tail call from the dispatcher; no recursion or captured locals',
+    outcomes: 'response, suspension, normalized application-error transfer, terminal failure',
+    suspension: 'resume the owning body by program counter; no live call stack',
+    budget: 'one charge per original state; the call reference adds no state'
+  }),
+  sharedStages: Object.freeze({
+    version: CANONICAL_NATIVE_STAGE_CONTRACT.version,
+    family: 'transfer-capable HTTP routes and middleware with 1..64 bound sequential text-fetch, time.now or crypto.digestText sites',
+    inputs: 'request context, stage-owned locals and registration-owned return/effect/continuation bindings',
+    outputs: 'response, next, error, suspension or terminal failure',
+    calls: 'dispatcher admission only; bounded pure loops retain canonical caps; no captures, recursion, helper calls, groups or effect loops',
+    suspension: 'one invocation-owned frame; reset locals at entry and retain across suspension'
+  }),
   suspension: 'explicit effect and effect-group statements with stable continuation IDs',
   values: 'versioned JSON expression tree with stable local identities',
   logging: 'compile-time threshold pruning plus synchronous provider-adapter emission',
@@ -134,8 +180,15 @@ const CANONICAL_NATIVE_PLAN_POLICY = Object.freeze({
 });
 
 module.exports = Object.freeze({
+  CANONICAL_NATIVE_PURE_LOOP_CALL_VERSION,
+  CANONICAL_NATIVE_PURE_BORROW_VERSION,
+  CANONICAL_NATIVE_TYPED_KV_BORROW_VERSION,
+  CANONICAL_NATIVE_PURE_HELPER_VERSION,
   CANONICAL_NATIVE_PLAN_VERSION,
+  CANONICAL_NATIVE_HANDLER_BODY_VERSION,
+  CANONICAL_NATIVE_STAGE_CONTRACT,
   CANONICAL_PURE_LOOP_LIMITS,
+  CANONICAL_READ_LOOP_CONTRACT,
   CANONICAL_NATIVE_PLAN_HASH_ALGORITHM,
   CANONICAL_NATIVE_PLAN_OWNERSHIP_VERSION,
   CANONICAL_NATIVE_STATEMENT_KINDS,

package/src/handler/canonical-native-runtime.js

@@ -2,9 +2,34 @@
 
 const CANONICAL_NATIVE_WASM_VERSION = 'pulse.canonical-native-wasm.v2';
 const CANONICAL_NATIVE_ABI_VERSION = 2;
-const CANONICAL_NATIVE_AS_GENERATOR_VERSION = 'pulse.canonical-native-as-generator.v3';
+const CANONICAL_NATIVE_AS_GENERATOR_VERSION = 'pulse.canonical-native-as-generator.v9';
 const CANONICAL_NATIVE_COMPILER_VERSION = 'pulse.canonical-native-wasm-compiler.v3';
-const CANONICAL_NATIVE_HOST_VERSION = 'pulse.canonical-native-host.v3';
+const CANONICAL_NATIVE_HOST_VERSION = 'pulse.canonical-native-host.v4';
+
+// Execution-wide containment for plans with bounded storage-read loops. These
+// are accounting limits, not a JavaScript process/RSS limit. Native providers
+// retain handles until completion; no iteration reset may refund this budget.
+const CANONICAL_NATIVE_READ_LOOP_MEMORY = Object.freeze({
+  version: 'pulse.native-read-loop-memory.v1',
+  maxBytes: 64 * 1024 * 1024,
+  maxValues: 1024 * 1024,
+  valueBytes: 32,
+  edgeBytes: 8,
+  maximumMemoryPages: 4096,
+  lifetime: 'execution',
+  reclamation: 'retain-until-terminal'
+});
+
+function hasBoundedReadLoop(plan) {
+  function visit(node) {
+    if (!node || typeof node !== 'object') return false;
+    return node.kind === 'read-loop' || Object.values(node).some(visit);
+  }
+  return visit(plan && plan.entry) || visit(plan && plan.handlers) || visit(plan && plan.helpers);
+}
+
+// Optional data-only host-to-guest JSON copy. UTF-8 accounting precedes guest allocation.
+const CANONICAL_NATIVE_VALUE_TRANSFER_MAX_BYTES = 1024 * 1024;
 
 const CANONICAL_NATIVE_RUN_STATUS = Object.freeze({
   COMPLETE: 0,
@@ -44,6 +69,8 @@ const CANONICAL_NATIVE_ASSIGNMENT_OPERATORS = Object.freeze([
 const CANONICAL_NATIVE_IMPORT_MODULE = 'pulse_host';
 const CANONICAL_NATIVE_ALLOWED_ENV_IMPORTS = Object.freeze(['abort', 'seed']);
 const CANONICAL_NATIVE_IMPORTS = Object.freeze([
+  // Optional, bounded JSON transfer into a managed guest string; no host authority.
+  ['value_json', ['i32'], ['i32']],
   ['value_undefined', [], ['i32']],
   ['value_null', [], ['i32']],
   ['value_boolean', ['i32'], ['i32']],
@@ -71,6 +98,9 @@ const CANONICAL_NATIVE_IMPORTS = Object.freeze([
   ['request_headers', [], ['i32']],
   ['request_header', ['i32'], ['i32']],
   ['request_text', [], ['i32']],
+  // Optional incoming-request-v1 extension: execution-local opaque marker,
+  // never a guest byte buffer or an invocation ticket. Older hosts fail import validation.
+  ['request_body', [], ['i32']],
   ['request_json', ['i32'], ['i32']],
   ['router_match', ['i32', 'i32'], ['i32']],
   ['router_param', ['i32', 'i32', 'i32'], ['i32']],
@@ -80,6 +110,8 @@ const CANONICAL_NATIVE_IMPORTS = Object.freeze([
   ['schema_encode', ['i32', 'i32'], ['i32']],
   ['schema_decode', ['i32', 'i32'], ['i32']],
   ['response_text', ['i32', 'i32'], ['i32']],
+  // Optional output-v1 extension, required only by generated-output artifacts.
+  ['output_close', [], ['i32']],
   ['response_custom', ['i32'], ['i32']],
   ['grip_is_websocket', [], ['i32']],
   ['grip_subscribe', ['i32', 'i32'], ['i32']],
@@ -119,6 +151,21 @@ const CANONICAL_NATIVE_IMPORT_NAMES = Object.freeze(CANONICAL_NATIVE_IMPORTS.map
 const CANONICAL_NATIVE_EXPORT_NAMES = Object.freeze(CANONICAL_NATIVE_EXPORTS.map(([name]) => name));
 const CANONICAL_NATIVE_SCHEMA_EXPORT_NAMES = Object.freeze(CANONICAL_NATIVE_SCHEMA_EXPORTS.map(([name]) => name));
 
+// Canonical compilation produces a Pulse host-ABI module before provider
+// packaging. Its imports are checked independently of the final provider ABI.
+const { defineFinalWasmPolicy, FINAL_WASM_POLICY_VERSION } = require('../provider/final-wasm-policy.js');
+const CANONICAL_NATIVE_FINAL_WASM_POLICY = defineFinalWasmPolicy({
+  version: FINAL_WASM_POLICY_VERSION,
+  descriptorOwner: '@pulse-compute/wasm-contracts',
+  toolchainVersion: 'pulse.provider-toolchain.v1',
+  descriptorIdentity: 'pulse-canonical-native-host',
+  permittedImports: [
+    ...CANONICAL_NATIVE_IMPORT_NAMES.map(name => ({ module: 'pulse_host', name, kind: 'function' })),
+    ...CANONICAL_NATIVE_ALLOWED_ENV_IMPORTS.map(name => ({ module: 'env', name, kind: 'function' }))
+  ],
+  requiredExports: CANONICAL_NATIVE_EXPORTS.map(([name, second]) => ({ name, kind: second === 'memory' ? 'memory' : 'function' }))
+});
+
 const CANONICAL_NATIVE_DIAGNOSTIC_CODES = Object.freeze({
   PLAN_REQUIRED: 'PULSE_CANONICAL_NATIVE_WASM_PLAN_REQUIRED',
   PLAN_INVALID: 'PULSE_CANONICAL_NATIVE_WASM_PLAN_INVALID',
@@ -143,6 +190,7 @@ const CANONICAL_NATIVE_POLICY = Object.freeze({
   suspension: 'effect_begin records descriptors before one explicit suspension boundary; results are injected before pulse_resume',
   groupedEffects: 'all group members begin before one suspension boundary and all results must be ready before resume',
   incompleteResume: 'rejected without advancing the program counter or consuming available results',
+  resultFreshness: 'managed hosts authenticate single-use invocation tickets; raw ABI v2 index/handle exports are trusted-host operations',
   authority: 'request data and consequential effects remain host-owned; guest control flow remains authoritative',
   schemaJson: 'normalized registry IR generates json-as 1.5.0 guest codecs; host preflight enforces shared policy and structured errors',
   schemaBodyOwnership: 'request and fetched-response bytes are snapshotted once; application JSON values are encoded before suspension'
@@ -154,6 +202,9 @@ module.exports = Object.freeze({
   CANONICAL_NATIVE_AS_GENERATOR_VERSION,
   CANONICAL_NATIVE_COMPILER_VERSION,
   CANONICAL_NATIVE_HOST_VERSION,
+  CANONICAL_NATIVE_READ_LOOP_MEMORY,
+  CANONICAL_NATIVE_VALUE_TRANSFER_MAX_BYTES,
+  hasBoundedReadLoop,
   CANONICAL_NATIVE_RUN_STATUS,
   CANONICAL_NATIVE_RESULT_STATUS,
   CANONICAL_NATIVE_ERROR_CODES,
@@ -169,5 +220,6 @@ module.exports = Object.freeze({
   CANONICAL_NATIVE_SCHEMA_EXPORTS,
   CANONICAL_NATIVE_SCHEMA_EXPORT_NAMES,
   CANONICAL_NATIVE_DIAGNOSTIC_CODES,
-  CANONICAL_NATIVE_POLICY
+  CANONICAL_NATIVE_POLICY,
+  CANONICAL_NATIVE_FINAL_WASM_POLICY
 });

package/src/handler/canonical-runtime.js

@@ -4,10 +4,19 @@ const CANONICAL_PROGRAM_VERSION = 'pulse.canonical-program.v2';
 const CANONICAL_RUNTIME_PROTOCOL_VERSION = 'pulse.canonical-runtime-protocol.v2';
 const CANONICAL_EFFECT_MARKER_KINDS = Object.freeze(['effect', 'group']);
 const CANONICAL_PACKAGE_EFFECT_VERSION = 'pulse.canonical-package-effect.v1';
+const CANONICAL_EFFECT_INVOCATION_POLICY = Object.freeze({
+  version: 'pulse.effect-invocation.v1',
+  defaultMaxEffects: 1024,
+  identity: 'execution-owned single-use ticket; static effect and continuation sites remain reusable',
+  terminal: 'completion, failure and cancellation invalidate outstanding tickets',
+  budget: 'cumulative effect invocations and one inherited monotonic deadline',
+  nativeResultBoundary: 'managed host; raw guest ABI v2 setters remain trusted-host operations'
+});
 
 module.exports = Object.freeze({
   CANONICAL_PROGRAM_VERSION,
   CANONICAL_RUNTIME_PROTOCOL_VERSION,
   CANONICAL_EFFECT_MARKER_KINDS,
-  CANONICAL_PACKAGE_EFFECT_VERSION
+  CANONICAL_PACKAGE_EFFECT_VERSION,
+  CANONICAL_EFFECT_INVOCATION_POLICY
 });

package/src/handler/surface-contract.js

@@ -57,6 +57,18 @@ function surface(definition) {
 }
 
 const HANDLER_SURFACE_DEFINITIONS = Object.freeze([
+  surface({ id: 'ctx.req.readTextChunk', class: 'effect', canonicalOperation: 'output.readTextChunk',
+    publicForms: ['ctx.req.readTextChunk()'], awaitPolicy: 'required-when-consumed', validPositions: ['statement'],
+    targetSupport: { javascript: true, native: true }, nativeBehavior: 'request-owned-input-suspension', status: 'experimental' }),
+  ...['start', 'write'].map(operation => surface({
+    id: `ctx.output.${operation}`, class: 'effect', canonicalOperation: `output.${operation}`,
+    publicForms: [`ctx.output.${operation}(...)`], awaitPolicy: 'required-when-consumed',
+    validPositions: ['statement'], targetSupport: { javascript: true, native: true },
+    nativeBehavior: 'request-owned-output-suspension', status: 'experimental'
+  })),
+  surface({ id: 'ctx.output.close', class: 'sync', canonicalOperation: 'response.output.close',
+    publicForms: ['ctx.output.close()'], awaitPolicy: 'forbidden', validPositions: ['return'],
+    targetSupport: { javascript: true, native: true }, nativeBehavior: 'terminal-output-marker', status: 'experimental' }),
   surface({
     id: 'handler.managed-async-wrapper',
     class: 'handler-wrapper',
@@ -269,6 +281,17 @@ const HANDLER_SURFACE_DEFINITIONS = Object.freeze([
     nativeBehavior: 'emit-effect-and-continuation',
     status: 'supported'
   }),
+  surface({
+    id: 'ctx.req.body',
+    class: 'sync',
+    canonicalOperation: 'request.body.forward-marker',
+    publicForms: ["ctx.fetch(url, { method: 'POST', body: ctx.req.body() })"],
+    awaitPolicy: 'forbidden',
+    validPositions: ['fetch-body'],
+    targetSupport: { javascript: true, native: true },
+    nativeBehavior: 'host-owned-marker',
+    status: 'node-configured-only'
+  }),
   surface({
     id: 'ctx.req.json.schema',
     class: 'effect',

package/src/jwt/contracts.js

@@ -17,7 +17,7 @@ const JWT_CONTRACT_ID = 'pulse.jwt';
 const JWT_PACKAGE_NAME = '@pulse-compute/jwt';
 
 const JWT_ALGORITHMS = Object.freeze(['HS256', 'RS256', 'ES256', 'EdDSA']);
-const JWT_IMPLEMENTED_ALGORITHMS = Object.freeze(['HS256', 'ES256']);
+const JWT_IMPLEMENTED_ALGORITHMS = Object.freeze(['HS256', 'ES256', 'RS256']);
 const JWT_KEY_TYPES = Object.freeze(['secret', 'jwk', 'jwks']);
 const JWT_IMPLEMENTED_KEY_TYPES = Object.freeze(['secret', 'jwk', 'jwks']);
 const JWT_NATIVE_REALIZATION_KINDS = Object.freeze(['crypto-composed']);
@@ -139,6 +139,38 @@ const JWT_VERIFY_OPERATION = Object.freeze({
   clock: 'provider-wall-clock'
 });
 
+const JWT_SIGN_OPERATION = Object.freeze({
+  version: JWT_CANONICAL_EFFECT_VERSION, contractId: JWT_CONTRACT_ID,
+  package: JWT_PACKAGE_NAME, import: JWT_PACKAGE_NAME,
+  kind: 'jwt.sign', providerKind: 'jwt', operation: 'sign', capability: 'jwt.sign',
+  result: 'string', placement: 'variable', clock: 'provider-wall-clock'
+});
+const JWT_SIGN_CONTRACT = Object.freeze({
+  version: 'pulse.jwt-sign.v2', algorithms: Object.freeze(['HS256', 'ES256', 'RS256']), keyType: 'secret',
+  kidBytesMaximum: 256, es256PrivateKey: 'secret-json-p256-private-jwk',
+  header: Object.freeze({ alg: 'selected-algorithm', typ: 'JWT', kid: 'optional-explicit-key-id' }),
+  claimsBytes: 8192, claimsEntries: 1024, claimsDepth: 32,
+  keyBytesMinimum: 32, keyBytesMaximum: 4096,
+  expiresInSecondsMinimum: 1, expiresInSecondsMaximum: Number.MAX_SAFE_INTEGER,
+  expirationSecondsMaximum: 8_640_000_000_000, lifetimePolicy: 'application-owned',
+  reservedClaims: Object.freeze(['iat', 'exp', 'nbf']),
+  providerRequirements: Object.freeze(['jwt.sign', 'secret.get', 'time.wall-clock']),
+  cryptoAlgorithms: Object.freeze({ HS256: 'HMAC-SHA256', ES256: 'ES256', RS256: 'RS256' }), automaticFallback: false
+});
+
+function normalizeJwtSignEffect(effect) {
+  if (!ordinaryObject(effect) || ['contractId', 'package', 'kind', 'providerKind', 'operation', 'capability', 'result']
+    .some(name => dataProperty(effect, name) !== JWT_SIGN_OPERATION[name])) {
+    throw new PulseJwtContractError('Pulse JWT provider received an invalid signing operation.', { field: 'identity' });
+  }
+  const payload = dataProperty(effect, 'payload');
+  if (!ordinaryObject(payload) || Reflect.ownKeys(payload).length !== 2
+    || !ordinaryObject(dataProperty(payload, 'claims')) || !ordinaryObject(dataProperty(payload, 'options'))) {
+    throw new PulseJwtContractError('Pulse JWT signing requires claims and options.', { field: 'payload' });
+  }
+  return Object.freeze({ claims: dataProperty(payload, 'claims'), options: dataProperty(payload, 'options') });
+}
+
 const JWT_EXECUTION_REQUIREMENTS = Object.freeze({
   containment: 'request-owned-effect',
   cancellation: 'request-lifecycle-signal',
@@ -175,6 +207,7 @@ const JWT_NATIVE_LOWERING_CONTRACT = Object.freeze({
     'jwt.verify',
     'jwt.verify.hs256',
     'jwt.verify.es256',
+    'jwt.verify.rs256',
     'secret.get',
     'time.wall-clock'
   ]),
@@ -192,6 +225,11 @@ const JWT_NATIVE_LOWERING_CONTRACT = Object.freeze({
       realization: 'guest-linked:pulse-es256-rustcrypto-p256',
       implementation: 'rustcrypto.p256-0.13.2.ecdsa-0.16.9.sha2-0.10.9.v1',
       guestUnitRequired: true
+    }),
+    RS256: Object.freeze({
+      realization: 'guest-linked:pulse-rs256-bearssl-i31',
+      implementation: 'bearssl.0.6.rsa-i31.sha256.v1',
+      guestUnitRequired: true
     })
   }),
   cryptoSemanticOwner: CRYPTO_SEMANTIC_OWNER,
@@ -414,6 +452,9 @@ module.exports = Object.freeze({
   JWT_RESOURCE_LIMITS,
   JWT_ES256_KEY_NORMALIZATION_CONTRACT,
   JWT_VERIFY_OPERATION,
+  JWT_SIGN_OPERATION,
+  JWT_SIGN_CONTRACT,
+  normalizeJwtSignEffect,
   JWT_EXECUTION_REQUIREMENTS,
   JWT_NATIVE_LOWERING_CONTRACT,
   JWT_TARGET_REALIZATIONS,

package/src/library/manifest.js

@@ -87,6 +87,7 @@ function normalizeManifest(manifest) {
       version: compiler.version,
       entry: compiler.entry,
       export: compiler.export,
+      ...(compiler.nativeApplicationExport !== undefined ? { nativeApplicationExport: compiler.nativeApplicationExport } : {}),
       artifact: compiler.artifact,
       builderOwner: compiler.builderOwner,
       trust: compiler.trust,
@@ -267,6 +268,16 @@ function validateLowerableLibraryManifest(manifest) {
     ));
   }
 
+  if (compiler.nativeApplicationExport !== undefined && (!isNonEmptyString(compiler.nativeApplicationExport)
+    || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(compiler.nativeApplicationExport))) {
+    diagnostics.push(makeDiagnostic(
+      'PULSEWASM_LOWERABLE_LIBRARY_COMPILER_EXPORT_REQUIRED',
+      'Native application builders must name a static compiler export.',
+      'Set compiler.nativeApplicationExport to an exported first-party builder function name.',
+      { nativeApplicationExport: compiler.nativeApplicationExport }
+    ));
+  }
+
   if (compiler.trust !== 'first-party') {
     diagnostics.push(makeDiagnostic(
       'PULSEWASM_LOWERABLE_LIBRARY_COMPILER_TRUST_REQUIRED',

package/src/project/native-optimization.js

@@ -2,8 +2,10 @@
 
 const NATIVE_OPTIMIZATION_VERSION = 'pulse.native-optimization.v1';
 const EXPERIMENTAL_NATIVE_SIZE_MODE = 'experimental-native-size';
+const EXPERIMENTAL_NATIVE_BOUNDED_SIZE_MODE = 'experimental-native-bounded-size';
 
 module.exports = Object.freeze({
   NATIVE_OPTIMIZATION_VERSION,
-  EXPERIMENTAL_NATIVE_SIZE_MODE
+  EXPERIMENTAL_NATIVE_SIZE_MODE,
+  EXPERIMENTAL_NATIVE_BOUNDED_SIZE_MODE
 });

package/src/provider/canonical-provider.js

@@ -5,9 +5,12 @@ const CANONICAL_PROVIDER_PLAN_VERSION = 'pulse.canonical-provider-plan.v1';
 
 const CANONICAL_PROVIDER_CAPABILITIES = Object.freeze([
   'request',
+  'request.body.forward',
   'response.json',
   'response.text',
   'response.custom',
+  'response.output',
+  'request.body.transform',
   'fetch',
   'time.wall-clock',
   'crypto.digestText',
@@ -23,10 +26,11 @@ const CANONICAL_PROVIDER_CAPABILITIES = Object.freeze([
   'grip.hold',
   'grip.publish',
   'grip.broadcast',
-  'jwt.verify',
+  'jwt.verify', 'jwt.sign',
   's3.head',
   's3.getText',
   's3.putText',
+  's3.getBody',
   'opaque.pass-through'
 ]);
 

package/src/provider/toolchain.js

@@ -52,6 +52,8 @@ const DRIVER_FIELDS = Object.freeze([
   'targets',
   'execute',
   'prepareNativeExecution',
+  'prepareNativeRequest',
+  'createGeneratedOutput',
   'createLoweringPlan',
   'inspectRealization',
   'writeTarget',
@@ -370,6 +372,10 @@ function defineProviderDriver(input, expected = {}) {
   if (input.prepareNativeExecution !== undefined && typeof input.prepareNativeExecution !== 'function') {
     throw new TypeError(`Pulse provider driver ${id} prepareNativeExecution must be a function.`);
   }
+  if (input.prepareNativeRequest !== undefined && typeof input.prepareNativeRequest !== 'function') {
+    throw new TypeError(`Pulse provider driver ${id} prepareNativeRequest must be a function.`);
+  }
+  if (input.createGeneratedOutput !== undefined && typeof input.createGeneratedOutput !== 'function') throw new TypeError('Pulse provider createGeneratedOutput must be a function.');
   const descriptor = input.descriptor === undefined ? undefined : normalizeDescriptor(input.descriptor);
   if (descriptor && descriptor.id !== id) throw new TypeError(`Pulse provider driver ${id} descriptor identity does not match.`);
   const javascript = normalizeJavascriptDriver(input.javascript, targets.javascript);
@@ -397,6 +403,8 @@ function defineProviderDriver(input, expected = {}) {
     targets,
     execute: input.execute,
     prepareNativeExecution: input.prepareNativeExecution,
+    prepareNativeRequest: input.prepareNativeRequest,
+    createGeneratedOutput: input.createGeneratedOutput,
     createLoweringPlan: input.createLoweringPlan,
     inspectRealization: input.inspectRealization,
     writeTarget: input.writeTarget,

package/src/s3/contracts.js

@@ -4,9 +4,9 @@ const S3_CONTRACT_ID = 'pulse.s3';
 const S3_PACKAGE = '@pulse-compute/s3';
 const S3_LOWERING_PLAN_VERSION = 'pulse.s3-lowering-plan.v1';
 const S3_LIMITS = Object.freeze({ keyBytes: 1024, textBytes: 2097152, defaultTextBytes: 32768, metadataBytes: 1024, headerBytes: 16384, envelopeBytes: 12648448 });
-const S3_OPERATIONS = Object.freeze(Object.fromEntries(['head', 'getText', 'putText'].map((name) => [name, Object.freeze({
-  kind: `s3.${name}`, capability: `s3.${name}`, result: name === 'head' ? 's3-head-result' : name === 'getText' ? 's3-get-text-result' : 's3-put-text-result'
+const S3_OPERATIONS = Object.freeze(Object.fromEntries(['head', 'getText', 'putText', 'getBody'].map((name) => [name, Object.freeze({
+  kind: `s3.${name}`, capability: `s3.${name}`, result: name === 'getBody' ? 'opaque-response' : name === 'head' ? 's3-head-result' : name === 'getText' ? 's3-get-text-result' : 's3-put-text-result'
 })])));
-const S3_PROVIDER_REQUIREMENTS = Object.freeze(['s3.head', 's3.getText', 's3.putText', 'secret.get', 'time.wall-clock']);
+const S3_PROVIDER_REQUIREMENTS = Object.freeze(['s3.head', 's3.getText', 's3.putText', 's3.getBody', 'secret.get', 'time.wall-clock']);
 const S3_CRYPTO_ALGORITHMS = Object.freeze(['SHA-256', 'HMAC-SHA256']);
 module.exports = Object.freeze({ S3_CONTRACT_ID, S3_PACKAGE, S3_LOWERING_PLAN_VERSION, S3_LIMITS, S3_OPERATIONS, S3_PROVIDER_REQUIREMENTS, S3_CRYPTO_ALGORITHMS });

package/src/schema-json/admission-text.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const { JsonAdmissionBudget } = require('./admission.js');
+
+class JsonAdmissionFrame {
+  kind/*: i32 */ = 0; // 0 array; 1 object
+  state/*: i32 */ = 0;
+  count/*: i32 */ = 0;
+  start/*: i32 */ = 0;
+  names/*: Map<string, i32> */ = new Map();
+}
+
+// Iterative syntax and resource admission; never constructs JSON containers.
+// Root containers have depth 1, root scalars depth 0. Nodes include every
+// syntactic value, even overwritten/unknown values. Keys are not value nodes.
+// duplicateMode: 0 allow, 1 reject, 2 report offsets for schema-owned policy.
+class JsonTextAdmission extends JsonAdmissionBudget {
+  text/*: string */;
+  duplicateMode/*: i32 */;
+  offset/*: i32 */ = 0;
+  textBytes/*: i32 */ = 0;
+  frames/*: Array<JsonAdmissionFrame> */ = [];
+  duplicateObjects/*: Array<i32> */ = [];
+  duplicateKeys/*: Array<i32> */ = [];
+  duplicateFirstKeys/*: Array<i32> */ = [];
+  constructor(text/*: string */, limits/*: JsonAdmissionLimits */, duplicateMode/*: i32 */) {
+    super(limits);
+    this.text = text;
+    this.duplicateMode = duplicateMode;
+  }
+  space()/*: void */ {
+    while (this.offset < this.text.length) {
+      const c = this.text.charCodeAt(this.offset);
+      if (c !== 32 && c !== 9 && c !== 10 && c !== 13) break;
+      this.offset++;
+    }
+  }
+  rawBytes()/*: bool */ {
+    // UTF-8 byte count matches replacement encoding for raw lone surrogates.
+    // This prepass stops before any syntax-frame or decoded-key allocation.
+    if (this.text.length > this.limits.maxTextBytes) return this.fail(2);
+    for (let i = 0; i < this.text.length; i++) {
+      const c = this.text.charCodeAt(i);
+      let n = c < 128 ? 1 : c < 2048 ? 2 : 3;
+      if (c >= 0xd800 && c <= 0xdbff && i + 1 < this.text.length) {
+        const next = this.text.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) { n = 4; i++; }
+      }
+      if (n > this.limits.maxTextBytes - this.textBytes) return this.fail(2);
+      this.textBytes += n;
+    }
+    return true;
+  }
+  string(key/*: bool */)/*: string */ {
+    const capture = key && this.duplicateMode !== 0;
+    const parts/*: Array<string> */ = [];
+    let length = 0;
+    let high = false;
+    this.offset++; // opening quote
+    if (!this.addBytes(2)) return '';
+    while (this.offset < this.text.length && this.failure === 0) {
+      let c = this.text.charCodeAt(this.offset++);
+      if (c === 34) {
+        if (high) this.addBytes(6);
+        return capture ? parts.join('') : '';
+      }
+      if (c < 32) { this.fail(1); return ''; }
+      if (c === 92) {
+        if (this.offset >= this.text.length) { this.fail(1); return ''; }
+        c = this.text.charCodeAt(this.offset++);
+        if (c === 117) {
+          let unit = 0;
+          for (let n = 0; n < 4; n++) {
+            if (this.offset >= this.text.length) { this.fail(1); return ''; }
+            const h = this.text.charCodeAt(this.offset++);
+            const digit = h >= 48 && h <= 57 ? h - 48 : h >= 65 && h <= 70 ? h - 55 : h >= 97 && h <= 102 ? h - 87 : -1;
+            if (digit < 0) { this.fail(1); return ''; }
+            unit = unit * 16 + digit;
+          }
+          c = unit;
+        } else if (c === 98) c = 8;
+        else if (c === 102) c = 12;
+        else if (c === 110) c = 10;
+        else if (c === 114) c = 13;
+        else if (c === 116) c = 9;
+        else if (c !== 34 && c !== 92 && c !== 47) { this.fail(1); return ''; }
+      }
+      const limit = key ? this.limits.maxKeyLength : this.limits.maxStringLength;
+      if (length >= limit) { this.fail(key ? 7 : 8); return ''; }
+      length++;
+      if (capture) parts.push(String.fromCharCode(c));
+      if (high) {
+        high = false;
+        if (c >= 0xdc00 && c <= 0xdfff) { this.addBytes(4); continue; }
+        if (!this.addBytes(6)) return '';
+      }
+      if (c >= 0xd800 && c <= 0xdbff) high = true;
+      else this.addBytes(c < 32 ? 6 : c === 34 || c === 92 ? 2 : c < 128 ? 1 : c < 2048 ? 2 : c >= 0xdc00 && c <= 0xdfff ? 6 : 3);
+    }
+    this.fail(1);
+    return '';
+  }
+  digit()/*: bool */ {
+    if (this.offset >= this.text.length) return false;
+    const c = this.text.charCodeAt(this.offset);
+    return c >= 48 && c <= 57;
+  }
+  number()/*: bool */ {
+    const start = this.offset;
+    if (this.text.charCodeAt(this.offset) === 45) this.offset++;
+    if (!this.digit()) return this.fail(1);
+    if (this.text.charCodeAt(this.offset) === 48) this.offset++;
+    else while (this.digit()) this.offset++;
+    if (this.offset < this.text.length && this.text.charCodeAt(this.offset) === 46) {
+      this.offset++;
+      if (!this.digit()) return this.fail(1);
+      while (this.digit()) this.offset++;
+    }
+    if (this.offset < this.text.length) {
+      const c = this.text.charCodeAt(this.offset);
+      if (c === 69 || c === 101) {
+        this.offset++;
+        if (this.offset < this.text.length && (this.text.charCodeAt(this.offset) === 43 || this.text.charCodeAt(this.offset) === 45)) this.offset++;
+        if (!this.digit()) return this.fail(1);
+        while (this.digit()) this.offset++;
+      }
+    }
+    if (!isFinite(parseFloat(this.text.substring(start, this.offset)))) return this.fail(11);
+    return this.addBytes(24); // finite-f64 conservative spelling budget
+  }
+  value()/*: bool */ {
+    this.space();
+    if (this.offset >= this.text.length) return this.fail(1);
+    const c = this.text.charCodeAt(this.offset);
+    const container = c === 91 || c === 123;
+    if (!this.node(container ? this.frames.length + 1 : this.frames.length)) return false;
+    if (container) {
+      if (!this.addBytes(1)) return false;
+      const frame = new JsonAdmissionFrame();
+      frame.kind = c === 123 ? 1 : 0;
+      frame.start = this.offset++;
+      this.frames.push(frame);
+      return true;
+    }
+    if (c === 34) { this.string(false); return this.failure === 0; }
+    let literal = '';
+    if (c === 116) literal = 'true';
+    else if (c === 102) literal = 'false';
+    else if (c === 110) literal = 'null';
+    if (literal.length > 0) {
+      if (this.text.substring(this.offset, this.offset + literal.length) !== literal) return this.fail(1);
+      this.offset += literal.length;
+      return this.addBytes(literal.length);
+    }
+    return this.number();
+  }
+  scan()/*: bool */ {
+    if (this.duplicateMode < 0 || this.duplicateMode > 2) return this.fail(12);
+    if (!this.rawBytes() || !this.value()) return false;
+    while (this.frames.length > 0 && this.failure === 0) {
+      this.space();
+      if (this.offset >= this.text.length) return this.fail(1);
+      const frame = this.frames[this.frames.length - 1];
+      const c = this.text.charCodeAt(this.offset);
+      const end = frame.kind === 0 ? 93 : 125;
+      const after = frame.kind === 0 ? 1 : 3;
+      if ((frame.state === 0 || frame.state === after) && c === end) {
+        this.offset++;
+        if (!this.addBytes(1)) return false;
+        this.frames.pop();
+      } else if (frame.state === after) {
+        if (c !== 44) return this.fail(1);
+        this.offset++;
+        if (!this.addBytes(1)) return false;
+        frame.state = frame.kind === 0 ? 2 : 4;
+      } else if (frame.kind === 0) {
+        if (frame.count >= this.limits.maxArrayItems) return this.fail(6);
+        frame.count++;
+        frame.state = 1;
+        if (!this.value()) return false;
+      } else if (frame.state === 0 || frame.state === 4) {
+        if (c !== 34) return this.fail(1);
+        if (frame.count >= this.limits.maxObjectMembers) return this.fail(5);
+        frame.count++;
+        const start = this.offset;
+        const name = this.string(true);
+        if (this.failure !== 0) return false;
+        if (this.duplicateMode !== 0) {
+          if (frame.names.has(name)) {
+            if (this.duplicateMode === 1) return this.fail(10);
+            this.duplicateObjects.push(frame.start);
+            this.duplicateKeys.push(start);
+            this.duplicateFirstKeys.push(frame.names.get(name)/* nonnull */);
+          } else frame.names.set(name, start);
+        }
+        frame.state = 1;
+      } else if (frame.state === 1) {
+        if (c !== 58) return this.fail(1);
+        this.offset++;
+        if (!this.addBytes(1)) return false;
+        frame.state = 2;
+      } else {
+        frame.state = 3;
+        if (!this.value()) return false;
+      }
+    }
+    this.space();
+    return this.failure === 0 && (this.offset === this.text.length || this.fail(1));
+  }
+}
+
+module.exports = { JsonAdmissionFrame, JsonTextAdmission };

package/src/schema-json/admission.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const { sha256Hex, stableStringify } = require('../stable-id.js');
+
+const JSON_ADMISSION_VERSION = 'pulse.json-admission.v1';
+const JSON_LIMIT_FIELDS = Object.freeze([
+  'maxTextBytes', 'maxDepth', 'maxNodes', 'maxObjectMembers',
+  'maxArrayItems', 'maxKeyLength', 'maxStringLength', 'maxJsonBytes'
+]);
+const JSON_ADMISSION_FAILURES = Object.freeze([
+  'none', 'malformed', 'text-bytes', 'depth', 'nodes', 'object-members',
+  'array-items', 'key-length', 'string-length', 'json-bytes',
+  'duplicate-key', 'non-finite-number', 'unsupported-value', 'cycle'
+]);
+
+// No application defaults in this internal foundation. All counters fit i32;
+// additions check remaining capacity before adding, including in generated AS.
+function normalizeJsonAdmissionLimits(input) {
+  const invalid = () => {
+    const error = new TypeError('JSON admission requires all eight positive i32 limits as own data properties.');
+    error.code = 'PULSEWASM_JSON_LIMITS_INVALID';
+    throw error;
+  };
+  if (!input || typeof input !== 'object' || Array.isArray(input)) invalid();
+  const proto = Object.getPrototypeOf(input);
+  if (proto !== Object.prototype && proto !== null) invalid();
+  const keys = Reflect.ownKeys(input);
+  if (keys.length !== JSON_LIMIT_FIELDS.length || keys.some(key => !JSON_LIMIT_FIELDS.includes(key))) invalid();
+  const limits = {};
+  for (const key of JSON_LIMIT_FIELDS) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (!descriptor || !Object.hasOwn(descriptor, 'value')) invalid();
+    const value = descriptor.value;
+    if (!Number.isInteger(value) || value < 1 || value > 0x7fffffff) invalid();
+    limits[key] = value;
+  }
+  return Object.freeze(limits);
+}
+
+function jsonAdmissionIdentity(input) {
+  const limits = normalizeJsonAdmissionLimits(input);
+  return Object.freeze({ version: JSON_ADMISSION_VERSION, limits,
+    hash: sha256Hex(stableStringify({ version: JSON_ADMISSION_VERSION, limits })) });
+}
+
+// These classes are executable reference semantics shared with Native codegen.
+// Type comments are erased by JavaScript and realized by the AS generator.
+class JsonAdmissionLimits {
+  maxTextBytes/*: i32 */ = 0;
+  maxDepth/*: i32 */ = 0;
+  maxNodes/*: i32 */ = 0;
+  maxObjectMembers/*: i32 */ = 0;
+  maxArrayItems/*: i32 */ = 0;
+  maxKeyLength/*: i32 */ = 0;
+  maxStringLength/*: i32 */ = 0;
+  maxJsonBytes/*: i32 */ = 0;
+}
+
+class JsonAdmissionBudget {
+  limits/*: JsonAdmissionLimits */;
+  failure/*: i32 */ = 0;
+  nodes/*: i32 */ = 0;
+  depth/*: i32 */ = 0;
+  jsonBytes/*: i32 */ = 0;
+  constructor(limits/*: JsonAdmissionLimits */) { this.limits = limits; }
+  fail(reason/*: i32 */)/*: bool */ {
+    if (this.failure === 0) this.failure = reason;
+    return false;
+  }
+  addBytes(amount/*: i32 */)/*: bool */ {
+    if (this.failure !== 0) return false;
+    if (amount < 0 || amount > this.limits.maxJsonBytes - this.jsonBytes) return this.fail(9);
+    this.jsonBytes += amount;
+    return true;
+  }
+  node(containerDepth/*: i32 */)/*: bool */ {
+    if (this.failure !== 0) return false;
+    if (this.nodes >= this.limits.maxNodes) return this.fail(4);
+    this.nodes++;
+    if (containerDepth > this.limits.maxDepth) return this.fail(3);
+    if (containerDepth > this.depth) this.depth = containerDepth;
+    return true;
+  }
+  stringBytes(text/*: string */, key/*: bool */)/*: bool */ {
+    if (text.length > (key ? this.limits.maxKeyLength : this.limits.maxStringLength)) return this.fail(key ? 7 : 8);
+    if (!this.addBytes(2)) return false;
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      let size = c < 32 ? 6 : c === 34 || c === 92 ? 2 : c < 128 ? 1 : c < 2048 ? 2 : 3;
+      if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length && text.charCodeAt(i + 1) >= 0xdc00 && text.charCodeAt(i + 1) <= 0xdfff) { size = 4; i++; }
+      else if (c >= 0xd800 && c <= 0xdfff) size = 6;
+      if (!this.addBytes(size)) return false;
+    }
+    return true;
+  }
+}
+
+module.exports = { JSON_ADMISSION_VERSION, JSON_LIMIT_FIELDS, JSON_ADMISSION_FAILURES,
+  normalizeJsonAdmissionLimits, jsonAdmissionIdentity, JsonAdmissionLimits, JsonAdmissionBudget };

package/src/schema-json/contracts.js

@@ -1,6 +1,7 @@
 'use strict';
 
 module.exports = {
+  admission: { ...require('./admission.js'), ...require('./admission-text.js') },
   v1: require('./v1.js'),
   v2: require('./v2.js'),
   compile: require('./compile.js'),

package/src/schema-json/registry.js

@@ -1,14 +1,49 @@
 'use strict';
 
 const { sha256Hex, stableStringify } = require('../stable-id.js');
+const { JSON_LIMIT_FIELDS, normalizeJsonAdmissionLimits } = require('./admission.js');
 
-const SCHEMA_REGISTRY_IR_VERSION = 'pulse.schema-registry-ir.v2';
-const SCHEMA_CODEC_INPUTS_VERSION = 'pulse.schema-codec-inputs.v2';
-const SCHEMA_AUTHORING_VERSION = 'pulse.schema-authoring.v1';
+const SCHEMA_REGISTRY_IR_VERSION = 'pulse.schema-registry-ir.v5';
+const SCHEMA_CODEC_INPUTS_VERSION = 'pulse.schema-codec-inputs.v5';
+const SCHEMA_AUTHORING_VERSION = 'pulse.schema-authoring.v3';
 const SCHEMA_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)+$/;
 const RESPONSE_CASE_ID_PATTERN = SCHEMA_ID_PATTERN;
 const SCALAR_KINDS = Object.freeze(['string', 'boolean', 'i32', 'u32', 'f64']);
-const NODE_KINDS = Object.freeze([...SCALAR_KINDS, 'object', 'array', 'string-enum', 'nullable']);
+const NODE_KINDS = Object.freeze([...SCALAR_KINDS, 'object', 'array', 'string-enum', 'nullable', 'scalar-record', 'json-value', 'json-object']);
+const SCALAR_RECORD_LIMITS = Object.freeze({ maxKeys: 32, maxKeyLength: 64, maxStringLength: 1024, maxBytes: 8192, numberBytes: 24 });
+const JSON_SCHEMA_DEFAULT_LIMITS = Object.freeze({ maxTextBytes: 65536, maxDepth: 32, maxNodes: 4096,
+  maxObjectMembers: 256, maxArrayItems: 1024, maxKeyLength: 256, maxStringLength: 16384, maxJsonBytes: 65536 });
+
+function normalizeJsonSchemaLimits(input = {}) {
+  if (!plainObject(input)) throw schemaContractError('PULSE_SCHEMA_JSON_LIMITS_INVALID', 'Schema JSON limits must be a static object.');
+  const values = { ...JSON_SCHEMA_DEFAULT_LIMITS };
+  for (const key of Reflect.ownKeys(input)) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (!JSON_LIMIT_FIELDS.includes(key) || !descriptor || !Object.hasOwn(descriptor, 'value')) {
+      throw schemaContractError('PULSE_SCHEMA_JSON_LIMITS_INVALID', 'Unknown JSON limit or non-data property.');
+    }
+    values[key] = descriptor.value;
+  }
+  try { return normalizeJsonAdmissionLimits(values); }
+  catch { throw schemaContractError('PULSE_SCHEMA_JSON_LIMITS_INVALID', 'JSON limits must be positive i32 integers.'); }
+}
+
+// Shared conservative UTF-8 JSON string sizing. Native code generation reuses
+// this pure function body; keep it independent of host APIs and mutable state.
+function scalarRecordStringBytes(text) {
+  let bytes = 2;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code < 32) bytes += 6;
+    else if (code === 34 || code === 92) bytes += 2;
+    else if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length && text.charCodeAt(i + 1) >= 0xdc00 && text.charCodeAt(i + 1) <= 0xdfff) { bytes += 4; i++; }
+    else if (code >= 0xd800 && code <= 0xdfff) bytes += 6;
+    else bytes += 3;
+  }
+  return bytes;
+}
 
 function schemaContractError(code, message, details = {}) {
   const error = new TypeError(message);
@@ -73,6 +108,14 @@ function normalizeSchemaNode(input, field = 'schema.root', stack = []) {
     throw schemaContractError('PULSE_SCHEMA_IR_NODE_KIND_UNSUPPORTED', `${field}.kind is unsupported: ${kind}.`, { field, kind });
   }
   if (SCALAR_KINDS.includes(kind)) return Object.freeze({ kind });
+  if (kind === 'json-value' || kind === 'json-object') return Object.freeze({ kind });
+  if (kind === 'scalar-record') {
+    if (input.limits !== undefined && (!plainObject(input.limits)
+      || stableStringify(input.limits) !== stableStringify(SCALAR_RECORD_LIMITS))) {
+      throw schemaContractError('PULSE_SCHEMA_IR_NODE_KIND_UNSUPPORTED', `${field} must use the fixed ScalarRecord limits.`, { field, kind });
+    }
+    return Object.freeze({ kind, limits: SCALAR_RECORD_LIMITS });
+  }
   if (kind === 'array') {
     return Object.freeze({ kind, element: normalizeSchemaNode(input.element, `${field}.element`, stack) });
   }
@@ -119,7 +162,13 @@ function normalizeSchemaNode(input, field = 'schema.root', stack = []) {
       source: entry.source ? normalizeSource(entry.source, `${field}.fields[${index}].source`) : undefined
     });
   });
-  return Object.freeze({ kind, fields: Object.freeze(fields) });
+  if (input.additionalProperties !== undefined
+    && (!plainObject(input.additionalProperties) || input.additionalProperties.kind !== 'json-value'
+      || Object.keys(input.additionalProperties).length !== 1)) {
+    throw schemaContractError('PULSE_SCHEMA_IR_NODE_KIND_UNSUPPORTED', `${field}.additionalProperties must be a JSON value policy.`, { field, kind });
+  }
+  return Object.freeze({ kind, fields: Object.freeze(fields),
+    ...(input.additionalProperties === undefined ? {} : { additionalProperties: Object.freeze({ kind: 'json-value' }) }) });
 }
 
 function normalizeSchema(input, index) {
@@ -135,6 +184,8 @@ function normalizeSchema(input, index) {
     id,
     typeName: requiredString(input.typeName, `schemas[${index}].typeName`),
     root,
+    ...(input.jsonLimits !== undefined || schemaHasNestedJson(root)
+      ? { jsonLimits: normalizeJsonSchemaLimits(input.jsonLimits) } : {}),
     source: normalizeSource(input.source, `schemas[${index}].source`)
   });
 }
@@ -196,9 +247,16 @@ function normalizeSchemaRegistry(input) {
       requiredFieldsOnly: false,
       optionalFields: 'omit-absent-own-properties',
       presentUndefined: 'reject',
-      unknownInputFields: 'drop',
-      outputFields: 'declared-only',
+      unknownInputFields: 'drop-unless-open',
+      outputFields: 'declared-and-admitted-open-properties',
       outputFieldOrder: 'declaration',
+      scalarRecords: 'bounded-own-scalar-properties',
+      scalarRecordDuplicateKeys: 'reject-after-unescaping',
+      nestedJson: 'bounded-recursive-json-values',
+      nestedJsonDuplicateKeys: 'reject-after-unescaping',
+      openObjects: 'known-fields-first-then-bounded-json-extras',
+      openObjectDuplicateKeys: 'reject-all-names-after-unescaping',
+      jsonAdmission: 'whole-document-before-materialization',
       numericPolicy: 'finite-rfc-json',
       parity: 'semantic',
       dynamicIds: false,
@@ -264,12 +322,30 @@ function schemaHasOptionalProperties(node) {
   return node.kind === 'object' && node.fields.some(field => !field.required || schemaHasOptionalProperties(field.value));
 }
 
+function schemaHasScalarRecord(node) {
+  if (node.kind === 'scalar-record') return true;
+  if (node.kind === 'nullable') return schemaHasScalarRecord(node.value);
+  if (node.kind === 'array') return schemaHasScalarRecord(node.element);
+  return node.kind === 'object' && node.fields.some(field => schemaHasScalarRecord(field.value));
+}
+
+function schemaNeedsValueProjection(node) {
+  return schemaHasOptionalProperties(node) || schemaHasScalarRecord(node) || schemaHasNestedJson(node);
+}
+
+function schemaHasNestedJson(node) {
+  if (node.kind === 'json-value' || node.kind === 'json-object') return true;
+  if (node.kind === 'nullable') return schemaHasNestedJson(node.value);
+  if (node.kind === 'array') return schemaHasNestedJson(node.element);
+  return node.kind === 'object' && (Boolean(node.additionalProperties) || node.fields.some(field => schemaHasNestedJson(field.value)));
+}
+
 function codecInputsForRegistry(registryInput) {
   const registry = normalizeSchemaRegistry(registryInput);
   const nativeSchemas = registry.schemas.map((schema) => {
     const schemaClasses = [];
     const symbols = new Map();
-    const presence = schemaHasOptionalProperties(schema.root);
+    const presence = schemaNeedsValueProjection(schema.root) || Boolean(schema.jsonLimits);
     if (!presence) collectNativeClasses(schema, schema.root, symbols, schemaClasses);
     const rootClass = presence ? 'JSON.Value' : symbols.get('');
     return Object.freeze({
@@ -336,7 +412,9 @@ function defaultSchemaRegistryContract() {
     scalarKinds: SCALAR_KINDS,
     nodeKinds: NODE_KINDS,
     helpers: ['defineSchemaRegistry', 'schema', 'response'],
-    markerTypes: ['Int32', 'Uint32'],
+    markerTypes: ['Int32', 'Uint32', 'ScalarRecord', 'JsonValue', 'JsonObject', 'OpenObject'],
+    scalarRecordLimits: SCALAR_RECORD_LIMITS,
+    jsonDefaultLimits: JSON_SCHEMA_DEFAULT_LIMITS,
     policies: {
       canonicalEntrypoint: 'pulse.schema',
       defaultExportRequired: true,
@@ -345,6 +423,10 @@ function defaultSchemaRegistryContract() {
       exactLiteralIdsAtBoundaries: true,
       oldSchemasJsonSupported: false,
       optionalPropertiesSupported: true,
+      scalarRecordsSupported: true,
+      nestedJsonSupported: true,
+      typedOpenObjectsSupported: true,
+      staticJsonLimitsSupported: true,
       recursiveSchemasSupported: false,
       publicJsonAsImportsSupported: false,
       automaticFallback: false
@@ -361,11 +443,18 @@ module.exports = Object.freeze({
   RESPONSE_CASE_ID_PATTERN,
   SCALAR_KINDS,
   NODE_KINDS,
+  SCALAR_RECORD_LIMITS,
+  JSON_SCHEMA_DEFAULT_LIMITS,
+  normalizeJsonSchemaLimits,
+  scalarRecordStringBytes,
   schemaContractError,
   normalizeSchemaNode,
   normalizeSchemaRegistry,
   codecInputsForRegistry,
   schemaHasOptionalProperties,
+  schemaHasScalarRecord,
+  schemaHasNestedJson,
+  schemaNeedsValueProjection,
   defaultSchemaBoundaryPolicy,
   defaultSchemaRegistryContract
 });