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

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.v1';
-const SCHEMA_CODEC_INPUTS_VERSION = 'pulse.schema-codec-inputs.v1';
-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) });
   }
@@ -106,20 +149,26 @@ function normalizeSchemaNode(input, field = 'schema.root', stack = []) {
       throw schemaContractError('PULSE_SCHEMA_IR_FIELD_DUPLICATE', `${field} declares field ${name} more than once.`, { field, name });
     }
     names.add(name);
-    if (entry.required !== true) {
-      throw schemaContractError('PULSE_SCHEMA_OPTIONAL_FIELD_RESERVED', `${field}.${name} must be required in schema IR v1.`, {
+    if (typeof entry.required !== 'boolean') {
+      throw schemaContractError('PULSE_SCHEMA_IR_FIELD_REQUIRED', `${field}.${name}.required must be a boolean.`, {
         field,
         name
       });
     }
     return Object.freeze({
       name,
-      required: true,
+      required: entry.required,
       value: normalizeSchemaNode(entry.value, `${field}.fields[${index}].value`, [...stack, name]),
       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`)
   });
 }
@@ -193,10 +244,19 @@ function normalizeSchemaRegistry(input) {
     responses,
     policies: deepFreeze({
       objectRoots: true,
-      requiredFieldsOnly: true,
-      unknownInputFields: 'drop',
-      outputFields: 'declared-only',
+      requiredFieldsOnly: false,
+      optionalFields: 'omit-absent-own-properties',
+      presentUndefined: 'reject',
+      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,
@@ -248,7 +308,7 @@ function collectNativeClasses(schema, node, symbols, classes, pathParts = []) {
     fields: Object.freeze(node.fields.map((field) => Object.freeze({
       name: field.name,
       type: assemblyScriptType(field.value, symbols, [...pathParts, field.name]),
-      required: true,
+      required: field.required,
       constraints: field.value.kind === 'string-enum'
         ? Object.freeze({ enum: field.value.values })
         : Object.freeze({})
@@ -256,18 +316,45 @@ function collectNativeClasses(schema, node, symbols, classes, pathParts = []) {
   }));
 }
 
+function schemaHasOptionalProperties(node) {
+  if (node.kind === 'nullable') return schemaHasOptionalProperties(node.value);
+  if (node.kind === 'array') return schemaHasOptionalProperties(node.element);
+  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();
-    collectNativeClasses(schema, schema.root, symbols, schemaClasses);
+    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({
       id: schema.id,
-      rootClass: symbols.get(''),
+      rootClass,
+      representation: presence ? 'schema-projected-json-value' : 'required-struct',
       classes: Object.freeze(schemaClasses),
-      parse: `JSON.parse<${symbols.get('')}>`,
-      stringify: `JSON.stringify<${symbols.get('')}>`
+      parse: `JSON.parse<${rootClass}>`,
+      stringify: `JSON.stringify<${rootClass}>`
     });
   });
   return deepFreeze({
@@ -325,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,
@@ -333,7 +422,11 @@ function defaultSchemaRegistryContract() {
       stableStringIds: true,
       exactLiteralIdsAtBoundaries: true,
       oldSchemasJsonSupported: false,
-      optionalPropertiesSupported: false,
+      optionalPropertiesSupported: true,
+      scalarRecordsSupported: true,
+      nestedJsonSupported: true,
+      typedOpenObjectsSupported: true,
+      staticJsonLimitsSupported: true,
       recursiveSchemasSupported: false,
       publicJsonAsImportsSupported: false,
       automaticFallback: false
@@ -350,10 +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
 });

package/src/schema-json/semantic-trace.js

@@ -7,13 +7,14 @@ const JSON_SEMANTIC_TRACE_VERSION = 'pulse.json-semantic-trace.v1';
 const JSON_TRACE_EVENT_KINDS = Object.freeze([
   'json.decode.request',
   'json.decode.fetch',
+  'json.decode.text',
   'json.encode.response',
   'json.encode.fetch',
   'json.encode.value',
   'json.decode.error',
   'json.encode.error'
 ]);
-const JSON_BOUNDARIES = Object.freeze(['request', 'fetch-response', 'application-response', 'fetch-request', 'application-value']);
+const JSON_BOUNDARIES = Object.freeze(['request', 'fetch-response', 'application-response', 'fetch-request', 'application-value', 'application-text']);
 const JSON_BODY_OWNERSHIP = Object.freeze([
   'request-snapshot',
   'fetched-response-snapshot',
@@ -23,10 +24,11 @@ const JSON_BODY_OWNERSHIP = Object.freeze([
 const JSON_EVENT_BOUNDARIES = Object.freeze({
   'json.decode.request': Object.freeze(['request']),
   'json.decode.fetch': Object.freeze(['fetch-response']),
+  'json.decode.text': Object.freeze(['application-text']),
   'json.encode.response': Object.freeze(['application-response']),
   'json.encode.fetch': Object.freeze(['fetch-request']),
   'json.encode.value': Object.freeze(['application-value']),
-  'json.decode.error': Object.freeze(['request', 'fetch-response']),
+  'json.decode.error': Object.freeze(['request', 'fetch-response', 'application-text']),
   'json.encode.error': Object.freeze(['application-response', 'fetch-request', 'application-value'])
 });