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

package/README.md

@@ -8,9 +8,9 @@
 > **Stability:** Internal schema compiler interface synchronized with this release set.<br>
 > **npm:** [`@pulse-compute/wasm-schema-json`](https://www.npmjs.com/package/@pulse-compute/wasm-schema-json)<br>
 > **Canonical replacement:** `schemas in .pulse/config.ts through the Pulse project workflow`<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.4/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.4` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.6` package policy.
 <!-- pulse-package-status:end -->
 
 JSON schema compiler, canonical codec, registry, sidecar, and body-policy implementation for Pulse.
@@ -35,4 +35,4 @@ Application projects declare schemas in `pulse.config.*`; they do not install or
 
 The exported compiler modules are synchronized implementation interfaces without an application-author compatibility promise.
 
-See [Explicit JSON schemas](https://pulsecompute.io/v1.0.0-beta.4/guides/json-schemas/), [Project configuration](https://pulsecompute.io/v1.0.0-beta.4/reference/project-config/#json-schema-policy), and [Implementation packages](https://pulsecompute.io/v1.0.0-beta.4/packages/implementation-packages/).
+See [Explicit JSON schemas](https://pulsecompute.io/v1.0.0-beta.6/guides/json-schemas/), [Project configuration](https://pulsecompute.io/v1.0.0-beta.6/reference/project-config/#json-schema-policy), and [Implementation packages](https://pulsecompute.io/v1.0.0-beta.6/packages/implementation-packages/).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulse-compute/wasm-schema-json",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "license": "Apache-2.0",
   "engines": {
     "node": "^22.14.0 || ^24.0.0"
@@ -19,8 +19,8 @@
     "./compiler/schema-registry": "./src/compiler/schema-registry.js"
   },
   "dependencies": {
-    "@pulse-compute/wasm-build-support": "1.0.0-beta.4",
-    "@pulse-compute/wasm-contracts": "1.0.0-beta.4",
+    "@pulse-compute/wasm-build-support": "1.0.0-beta.6",
+    "@pulse-compute/wasm-contracts": "1.0.0-beta.6",
     "typescript": "5.9.3"
   },
   "publishConfig": {
@@ -37,7 +37,7 @@
     "url": "git+https://github.com/pulse-compute/pulse.git",
     "directory": "wasm/packages/schema-json"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.4/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/compiler/canonical-schema-codecs.js

@@ -3,18 +3,23 @@
 const crypto = require('node:crypto');
 const {
   SCHEMA_REGISTRY_IR_VERSION,
-  normalizeSchemaRegistry
+  normalizeSchemaRegistry,
+  scalarRecordStringBytes,
+  schemaHasScalarRecord,
+  schemaHasNestedJson
 } = require('@pulse-compute/wasm-contracts/schema-json/registry');
+const { projectScalarRecord, validateScalarRecordText } = require('./scalar-record-codec.js');
+const { javascriptJsonAdmissionSource } = require('./json-admission.js');
 const {
   normalizeJsonTraceEvent,
   semanticValueDigest
 } = require('@pulse-compute/wasm-contracts/schema-json/semantic-trace');
 
-const CANONICAL_SCHEMA_BUNDLE_VERSION = 'pulse.canonical-schema-bundle.v2';
-const CANONICAL_SCHEMA_REGISTRY_VERSION = 'pulse.canonical-schema-registry.v2';
-const CANONICAL_SCHEMA_CODECS_VERSION = 'pulse.canonical-schema-codecs.v2';
-const JAVASCRIPT_SCHEMA_CODEC_VERSION = 'pulse.javascript-schema-codec.v1';
-const NATIVE_SCHEMA_CODEC_VERSION = 'pulse.native-json-as-schema-codec.v1';
+const CANONICAL_SCHEMA_BUNDLE_VERSION = 'pulse.canonical-schema-bundle.v4';
+const CANONICAL_SCHEMA_REGISTRY_VERSION = 'pulse.canonical-schema-registry.v4';
+const CANONICAL_SCHEMA_CODECS_VERSION = 'pulse.canonical-schema-codecs.v4';
+const JAVASCRIPT_SCHEMA_CODEC_VERSION = 'pulse.javascript-schema-codec.v4';
+const NATIVE_SCHEMA_CODEC_VERSION = 'pulse.native-json-as-schema-codec.v4';
 
 function stableObject(value) {
   if (Array.isArray(value)) return value.map(stableObject);
@@ -105,6 +110,7 @@ function canonicalRegistry(input, options = {}) {
       registryHash: registryIr.registryHash,
       id: schema.id,
       root: schema.root,
+      ...(schema.jsonLimits ? { jsonLimits: schema.jsonLimits, boundaryMaxBytes: maxBytes } : {}),
       policies: registryIr.policies
     };
     const semanticHash = stableHash(semantic);
@@ -155,6 +161,16 @@ function renderCanonicalSchemaCodecDeclaration(registryInput, options = {}) {
   const codecsName = options.codecsName || '__pulse_schema_codecs';
   const lines = [];
   lines.push(`const ${registryName} = Object.freeze(${JSON.stringify(registry, null, 2)});`);
+  const scalarRecords = registry.schemas.some(schema => schemaHasScalarRecord(schema.root));
+  const nestedJson = registry.schemas.some(schema => schemaHasNestedJson(schema.root));
+  const admission = registry.schemas.some(schema => schema.jsonLimits);
+  if (admission) lines.push(javascriptJsonAdmissionSource());
+  if (scalarRecords || nestedJson) {
+    // Keep generated declarations in the existing reserved schema namespace.
+    for (const helper of [scalarRecordStringBytes, projectScalarRecord, validateScalarRecordText]) {
+      lines.push(helper.toString().replace(/\b(scalarRecordStringBytes|projectScalarRecord|validateScalarRecordText)\b/g, name => '__pulse_schema_' + name));
+    }
+  }
   lines.push('function __pulse_schema_kind(value) {');
   lines.push("  if (value === null) return 'null';");
   lines.push("  if (Array.isArray(value)) return 'array';");
@@ -189,6 +205,17 @@ function renderCanonicalSchemaCodecDeclaration(registryInput, options = {}) {
   lines.push('}');
   lines.push('function __pulse_schema_apply_node(node, value, mode, schemaId, path, source) {');
   lines.push('  const kind = node.kind;');
+  if (nestedJson) {
+    lines.push("  if (kind === 'json-value') return value;");
+    lines.push("  if (kind === 'json-object') {");
+    lines.push("    if (!value || typeof value !== 'object' || Array.isArray(value)) throw __pulse_schema_failure(mode, undefined, schemaId, path, 'json-object', __pulse_schema_kind(value), source);");
+    lines.push('    return value;', '  }');
+  }
+  if (scalarRecords) {
+    lines.push("  if (kind === 'scalar-record') return __pulse_schema_projectScalarRecord(value, node.limits, (key, expected, actual) => {");
+    lines.push('    throw __pulse_schema_failure(mode, undefined, schemaId, key === null ? path : __pulse_schema_pointer(path, key), expected, actual, source);');
+    lines.push('  });');
+  }
   lines.push("  if (kind === 'nullable') {");
   lines.push("    if (value === null) return null;");
   lines.push('    return __pulse_schema_apply_node(node.value, value, mode, schemaId, path, source);');
@@ -225,10 +252,15 @@ function renderCanonicalSchemaCodecDeclaration(registryInput, options = {}) {
   lines.push("    if (!value || typeof value !== 'object' || Array.isArray(value)) throw __pulse_schema_failure(mode, undefined, schemaId, path, 'object', __pulse_schema_kind(value), source);");
   lines.push('    const output = {};');
   lines.push('    for (const field of node.fields) {');
+  lines.push("      if (!field.required && !Object.prototype.hasOwnProperty.call(value, field.name)) continue;");
   lines.push('      const fieldPath = __pulse_schema_pointer(path, field.name);');
   lines.push('      const fieldValue = __pulse_schema_data_value(value, field.name, mode, schemaId, fieldPath, source);');
   lines.push('      Object.defineProperty(output, field.name, { enumerable: true, configurable: false, writable: false, value: __pulse_schema_apply_node(field.value, fieldValue, mode, schemaId, fieldPath, source) });');
   lines.push('    }');
+  lines.push('    if (node.additionalProperties) for (const key of Object.keys(value)) {');
+  lines.push('      if (node.fields.some(field => field.name === key)) continue;');
+  lines.push('      Object.defineProperty(output, key, { enumerable: true, value: value[key] });');
+  lines.push('    }');
   lines.push('    return Object.freeze(output);');
   lines.push('  }');
   lines.push("  throw __pulse_schema_failure(mode, undefined, schemaId, path, 'supported-schema-node', String(kind), source);");
@@ -237,6 +269,10 @@ function renderCanonicalSchemaCodecDeclaration(registryInput, options = {}) {
   registry.schemas.forEach((schema, index) => {
     const fn = schemaFunctionName(registry, index);
     lines.push(`function ${fn}(value, mode, source) {`);
+    if (schema.jsonLimits) {
+      lines.push(`  try { value = __pulse_schema_inspectJsonValue(value, ${registryName}.schemas[${index}].jsonLimits, true).value; }`);
+      lines.push(`  catch (cause) { throw __pulse_schema_failure(mode, undefined, ${JSON.stringify(schema.id)}, '', 'bounded-json', cause.detail?.reason || 'unsupported-value', source, cause); }`);
+    }
     lines.push(`  return __pulse_schema_apply_node(${registryName}.schemas[${index}].root, value, mode, ${JSON.stringify(schema.id)}, '', source);`);
     lines.push('}');
   });
@@ -263,15 +299,41 @@ function renderCanonicalSchemaCodecDeclaration(registryInput, options = {}) {
   lines.push("  decode(schemaId, value, source = 'json') { return __pulse_schema_apply(schemaId, value, 'decode', source); },");
   lines.push("  encode(schemaId, value, source = 'response') { return __pulse_schema_apply(schemaId, value, 'encode', source); },");
   lines.push("  decodeJsonText(schemaId, text, source = 'json') {");
+  lines.push('    const schema = this.schema(schemaId);');
+  lines.push('    if (!schema) throw __pulse_schema_reference_error(schemaId, source);');
+  if (admission) {
+    lines.push('    let duplicates = [];');
+    lines.push('    if (schema.jsonLimits) {');
+    lines.push('      const limits = { ...schema.jsonLimits, maxTextBytes: Math.min(schema.jsonLimits.maxTextBytes, this.registry.maxBytes) };');
+    lines.push('      const scan = new __pulse_schema_JsonTextAdmission(String(text), limits, 2);');
+    lines.push("      if (!scan.scan()) throw __pulse_schema_failure('decode', scan.failure === 1 ? 'PULSE_SCHEMA_JSON_MALFORMED' : scan.failure === 2 ? 'PULSE_BODY_TOO_LARGE' : undefined, String(schemaId), '', 'bounded-json', __pulse_schema_JSON_ADMISSION_FAILURES[scan.failure], source);");
+    lines.push('      duplicates = scan.duplicateObjects;', '    }');
+  }
+  if ((scalarRecords || nestedJson) && admission) {
+    lines.push("    if (schema.jsonLimits) __pulse_schema_validateScalarRecordText(String(text), schema.root, (path, expected, actual) => { throw __pulse_schema_failure('decode', undefined, String(schemaId), path, expected, actual, source); }, duplicates);");
+  }
   lines.push('    let value;');
   lines.push('    try { value = JSON.parse(String(text)); }');
   lines.push("    catch (cause) { throw __pulse_schema_failure('decode', 'PULSE_SCHEMA_JSON_MALFORMED', String(schemaId), '', 'valid-json', 'malformed-json', source, cause); }");
+  if (scalarRecords) {
+    lines.push("    if (!schema.jsonLimits) __pulse_schema_validateScalarRecordText(String(text), schema.root, (path, expected, actual) => { throw __pulse_schema_failure('decode', undefined, String(schemaId), path, expected, actual, source); });");
+  }
   lines.push("    return __pulse_schema_apply(schemaId, value, 'decode', source);");
   lines.push('  },');
   lines.push("  encodeJsonText(schemaId, value, source = 'response') {");
   lines.push("    const normalized = __pulse_schema_apply(schemaId, value, 'encode', source);");
-  lines.push('    try { return JSON.stringify(normalized); }');
+  lines.push('    let text;');
+  lines.push('    try { text = JSON.stringify(normalized); }');
   lines.push("    catch (cause) { throw __pulse_schema_failure('encode', 'PULSE_SCHEMA_ENCODE', String(schemaId), '', 'serializable-json', __pulse_schema_kind(normalized), source, cause); }");
+  if (admission) {
+    lines.push('    const schema = this.schema(schemaId);');
+    lines.push('    if (schema.jsonLimits) {');
+    lines.push('      const limits = { ...schema.jsonLimits, maxTextBytes: Math.min(schema.jsonLimits.maxTextBytes, this.registry.maxBytes) };');
+    lines.push('      const scan = new __pulse_schema_JsonTextAdmission(text, limits, 0);');
+    lines.push("      if (!scan.scan()) throw __pulse_schema_failure('encode', scan.failure === 2 ? 'PULSE_BODY_TOO_LARGE' : undefined, String(schemaId), '', 'bounded-json', __pulse_schema_JSON_ADMISSION_FAILURES[scan.failure], source);");
+    lines.push('    }');
+  }
+  lines.push('    return text;');
   lines.push('  }');
   lines.push('});');
   return `${lines.join('\n')}\n`;

package/src/compiler/index.js

@@ -6,8 +6,10 @@ const schemaJsonGenericParser = require('./schema-json-generic-parser.js');
 const schemaJsonSidecarV2 = require('./schema-json-sidecar-v2.js');
 const canonicalSchemaCodecs = require('./canonical-schema-codecs.js');
 const schemaRegistry = require('./schema-registry.js');
+const jsonAdmission = require('./json-admission.js');
 
 module.exports = {
+  jsonAdmission,
   schemaJsonCompile,
   schemaJsonSidecar,
   schemaJsonGenericParser,

package/src/compiler/json-admission.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const { admission } = require('@pulse-compute/wasm-contracts/schema-json/contracts');
+const { normalizeJsonAdmissionLimits, JsonAdmissionBudget, JsonTextAdmission, JSON_ADMISSION_FAILURES } = admission;
+
+function jsonAdmissionFailure(budget, offset = -1) {
+  const error = new TypeError(`JSON admission failed: ${JSON_ADMISSION_FAILURES[budget.failure]}.`);
+  error.code = 'PULSEWASM_JSON_ADMISSION_FAILED';
+  error.detail = Object.freeze({ reason: JSON_ADMISSION_FAILURES[budget.failure], offset });
+  throw error;
+}
+
+function jsonAdmissionSummary(budget) {
+  return { nodes: budget.nodes, depth: budget.depth, jsonBytes: budget.jsonBytes };
+}
+
+function admitJsonText(text, input, duplicatePolicy = 'allow') {
+  const limits = normalizeJsonAdmissionLimits(input);
+  if (typeof text !== 'string') throw new TypeError('JSON admission text must be a string.');
+  const mode = ['allow', 'reject', 'report'].indexOf(duplicatePolicy);
+  if (mode < 0) throw new TypeError('Unknown JSON duplicate policy.');
+  const scanner = new JsonTextAdmission(text, limits, mode);
+  if (!scanner.scan()) jsonAdmissionFailure(scanner, scanner.offset);
+  const duplicates = scanner.duplicateObjects.map((objectStart, index) => Object.freeze({
+    objectStart, keyStart: scanner.duplicateKeys[index], firstKeyStart: scanner.duplicateFirstKeys[index]
+  }));
+  return Object.freeze({ ...jsonAdmissionSummary(scanner), textBytes: scanner.textBytes, duplicates: Object.freeze(duplicates) });
+}
+
+// The continuation runs only after admission. Existing schemas do not select
+// this internal seam; it establishes ordering for subsequent codec integration.
+function withAdmittedJsonText(text, limits, materialize, duplicatePolicy = 'allow') {
+  const result = admitJsonText(text, limits, duplicatePolicy);
+  return materialize(text, result);
+}
+
+function admitJsonValue(root, input) {
+  const limits = normalizeJsonAdmissionLimits(input);
+  return inspectJsonValue(root, limits);
+}
+
+// A generated schema codec uses normalized limits and requests one detached,
+// immutable snapshot. Admission and copying share a traversal, so no second
+// read of an application property can replace an already-admitted child.
+function inspectJsonValue(root, limits, project = false) {
+  const budget = new JsonAdmissionBudget(limits);
+  const active = new Set();
+  const stack = [];
+  const fail = reason => { budget.fail(reason); jsonAdmissionFailure(budget); };
+  const bytes = size => { if (!budget.addBytes(size)) jsonAdmissionFailure(budget); };
+  function string(text, key) {
+    if (!budget.stringBytes(text, key)) jsonAdmissionFailure(budget);
+  }
+  function value(item) {
+    const container = item !== null && typeof item === 'object';
+    if (!budget.node(stack.length + (container ? 1 : 0))) jsonAdmissionFailure(budget);
+    if (!container) {
+      if (item === null) bytes(4);
+      else if (typeof item === 'boolean') bytes(item ? 4 : 5);
+      else if (typeof item === 'string') string(item, false);
+      else if (typeof item === 'number') { if (!Number.isFinite(item)) fail(11); bytes(24); }
+      else fail(12);
+      return item;
+    }
+    if (active.has(item)) fail(13);
+    const array = Array.isArray(item);
+    const proto = Object.getPrototypeOf(item);
+    if (array ? proto !== Array.prototype : proto !== Object.prototype && proto !== null) fail(12);
+    if (array && item.length > limits.maxArrayItems) fail(6);
+    // JS has no incremental own-key reflection primitive. This enumerates the
+    // already-created input, then bounds our traversal stack before retaining
+    // frames or reading descriptors. It does not construct a projected object.
+    const keys = Reflect.ownKeys(item);
+    if (array) {
+      if (keys.length !== item.length + 1) fail(12); // dense, no extra properties
+    } else if (keys.length > limits.maxObjectMembers) fail(5);
+    if (keys.some(key => typeof key !== 'string')) fail(12);
+    bytes(2); // opening and closing delimiters
+    active.add(item);
+    const output = project ? (array ? [] : {}) : null;
+    stack.push({ item, output, array, keys, index: 0, count: array ? item.length : keys.length });
+    return output;
+  }
+  const output = value(root);
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (frame.index === frame.count) {
+      if (project) Object.freeze(frame.output);
+      active.delete(frame.item); stack.pop(); continue;
+    }
+    const index = frame.index++;
+    const key = frame.array ? String(index) : frame.keys[index];
+    if (index > 0) bytes(1);
+    if (!frame.array) { string(key, true); bytes(1); }
+    const descriptor = Object.getOwnPropertyDescriptor(frame.item, key);
+    if (!descriptor || !Object.hasOwn(descriptor, 'value') || !descriptor.enumerable) fail(12);
+    const child = value(descriptor.value);
+    if (project) Object.defineProperty(frame.output, key, { value: child, enumerable: true });
+  }
+  return Object.freeze({ ...jsonAdmissionSummary(budget), ...(project ? { value: output } : {}) });
+}
+
+function javascriptJsonAdmissionSource() {
+  const classes = [admission.JsonAdmissionBudget, admission.JsonAdmissionFrame, admission.JsonTextAdmission];
+  return (`const JSON_ADMISSION_FAILURES = ${JSON.stringify(JSON_ADMISSION_FAILURES)};\n`
+    + [...classes, jsonAdmissionFailure, jsonAdmissionSummary, inspectJsonValue].map(value => value.toString()).join('\n'))
+    .replace(/\b(JSON_ADMISSION_FAILURES|JsonAdmissionBudget|JsonAdmissionFrame|JsonTextAdmission|jsonAdmissionFailure|jsonAdmissionSummary|inspectJsonValue)\b/g,
+      name => '__pulse_schema_' + name);
+}
+
+module.exports = { admitJsonText, withAdmittedJsonText, admitJsonValue, javascriptJsonAdmissionSource };

package/src/compiler/scalar-record-codec.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const { scalarRecordStringBytes } = require('@pulse-compute/wasm-contracts/schema-json/registry');
+
+// These functions are embedded into emitted JavaScript codecs. They use only
+// their arguments, standard JavaScript, and the shared string-sizing function.
+function projectScalarRecord(value, limits, fail) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)) {
+    fail(null, 'scalar-record', value === null ? 'null' : typeof value);
+  }
+  const keys = Object.getOwnPropertyNames(value).sort();
+  if (keys.length > limits.maxKeys) fail(null, 'at-most-' + limits.maxKeys + '-keys', 'too-many-keys');
+  if (Object.getOwnPropertySymbols(value).length) fail(null, 'string-keys', 'symbol');
+  const output = {};
+  let bytes = 2;
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index];
+    if (key.length > limits.maxKeyLength) fail(key, 'bounded-key', 'key-too-long');
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) fail(key, 'data-property', 'accessor');
+    const item = descriptor.value;
+    let size;
+    if (item === null) size = 4;
+    else if (typeof item === 'string') {
+      if (item.length > limits.maxStringLength) fail(key, 'bounded-string', 'string-too-long');
+      size = scalarRecordStringBytes(item);
+    } else if (typeof item === 'boolean') size = item ? 4 : 5;
+    else if (typeof item === 'number' && Number.isFinite(item)) size = limits.numberBytes;
+    else fail(key, 'string|finite-number|boolean|null', Array.isArray(item) ? 'array' : typeof item);
+    bytes += (index === 0 ? 0 : 1) + scalarRecordStringBytes(key) + 1 + size;
+    if (bytes > limits.maxBytes) fail(null, 'bounded-scalar-record', 'byte-budget-exceeded');
+    Object.defineProperty(output, key, { enumerable: true, value: item });
+  }
+  return Object.freeze(output);
+}
+
+// JSON.parse still owns syntax. Scan only schema-selected records in valid
+// JSON before exposing values; ordinary object fields keep last-member-wins.
+function validateScalarRecordText(text, root, fail, duplicateObjects = []) {
+  function space(i) { while (i < text.length && text.charCodeAt(i) <= 32) i++; return i; }
+  function stringEnd(i) {
+    for (i++; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === 92) i++;
+      else if (c === 34) return i + 1;
+    }
+    return text.length;
+  }
+  function end(i) {
+    i = space(i);
+    if (text[i] === '"') return stringEnd(i);
+    if (text[i] !== '{' && text[i] !== '[') {
+      while (i < text.length && !',]} \t\r\n'.includes(text[i])) i++;
+      return i;
+    }
+    let depth = 0;
+    for (; i < text.length; i++) {
+      const c = text[i];
+      if (c === '"') i = stringEnd(i) - 1;
+      else if (c === '{' || c === '[') depth++;
+      else if ((c === '}' || c === ']') && --depth === 0) return i + 1;
+    }
+    return text.length;
+  }
+  function visit(node, start, path) {
+    start = space(start);
+    if (node.kind === 'json-value' || node.kind === 'json-object') {
+      const stop = end(start);
+      if (duplicateObjects.some(offset => offset >= start && offset < stop)) fail(path, 'unique-keys', 'duplicate-key');
+      return;
+    }
+    if (node.kind === 'nullable') { visit(node.value, start, path); return; }
+    if (node.kind === 'array' && text[start] === '[') {
+      let i = space(start + 1), index = 0;
+      while (i < text.length && text[i] !== ']') {
+        visit(node.element, i, path + '/' + index++);
+        i = space(end(i));
+        if (text[i] !== ',') break;
+        i = space(i + 1);
+      }
+    } else if ((node.kind === 'object' || node.kind === 'scalar-record') && text[start] === '{') {
+      if (node.additionalProperties && duplicateObjects.includes(start)) fail(path, 'unique-keys', 'duplicate-key');
+      const names = new Set(), fields = new Map();
+      let i = space(start + 1);
+      while (i < text.length && text[i] !== '}') {
+        const keyEnd = stringEnd(i), key = JSON.parse(text.slice(i, keyEnd));
+        i = space(space(keyEnd) + 1);
+        if (node.kind === 'scalar-record') {
+          if (names.has(key)) fail(path, 'unique-keys', 'duplicate-key');
+          names.add(key);
+          if (names.size > node.limits.maxKeys) fail(path, 'bounded-scalar-record', 'too-many-keys');
+        } else {
+          const field = node.fields.find(field => field.name === key);
+          if (field) fields.set(key, { node: field.value, start: i });
+          else if (node.additionalProperties) fields.set(key, { node: node.additionalProperties, start: i });
+        }
+        i = space(end(i));
+        if (text[i] !== ',') break;
+        i = space(i + 1);
+      }
+      for (const [key, field] of fields) visit(field.node, field.start, path + '/' + key.replace(/~/g, '~0').replace(/\//g, '~1'));
+    }
+  }
+  visit(root, 0, '');
+}
+
+module.exports = { projectScalarRecord, validateScalarRecordText };

package/src/compiler/schema-registry.js

@@ -5,13 +5,14 @@ const path = require('node:path');
 const ts = require('typescript');
 const {
   normalizeSchemaRegistry,
-  codecInputsForRegistry
+  codecInputsForRegistry,
+  normalizeJsonSchemaLimits
 } = require('@pulse-compute/wasm-contracts/schema-json/registry');
 
-const SCHEMA_REGISTRY_EXTRACTOR_VERSION = 'pulse.schema-registry-extractor.v1';
+const SCHEMA_REGISTRY_EXTRACTOR_VERSION = 'pulse.schema-registry-extractor.v3';
 const AUTHORING_MODULE = '@pulse-compute/pulse/schema';
 const HELPER_EXPORTS = new Set(['defineSchemaRegistry', 'schema', 'response']);
-const MARKER_EXPORTS = new Map([['Int32', 'i32'], ['Uint32', 'u32']]);
+const MARKER_EXPORTS = new Map([['Int32', 'i32'], ['Uint32', 'u32'], ['ScalarRecord', 'scalar-record'], ['JsonValue', 'json-value'], ['JsonObject', 'json-object'], ['OpenObject', 'open-object']]);
 
 class SchemaRegistryExtractionError extends Error {
   constructor(code, message, detail = {}) {
@@ -232,13 +233,13 @@ class TypeGraph {
             fail('PULSE_SCHEMA_HELPER_VALUE_IMPORT_REQUIRED', `${imported} must be imported as a value.`, element, record, { imported });
           }
           record.helpers.set(local, imported);
-        } else if (MARKER_EXPORTS.has(imported)) {
+        } else if (MARKER_EXPORTS.has(imported) || imported === 'JsonLimits' || imported === 'SchemaOptions') {
           if (!clause.isTypeOnly && !element.isTypeOnly) {
             fail('PULSE_SCHEMA_MARKER_TYPE_IMPORT_REQUIRED', `${imported} must be imported with import type.`, element, record, {
               imported
             });
           }
-          record.markers.set(local, MARKER_EXPORTS.get(imported));
+          if (MARKER_EXPORTS.has(imported)) record.markers.set(local, MARKER_EXPORTS.get(imported));
         } else {
           fail('PULSE_SCHEMA_AUTHORING_IMPORT_UNKNOWN', `Unsupported schema authoring import ${imported}.`, element, record, {
             imported
@@ -285,6 +286,14 @@ class TypeGraph {
         record
       );
     }
+    if (statement.moduleSpecifier.text === AUTHORING_MODULE && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) {
+        const imported = element.propertyName ? element.propertyName.text : element.name.text;
+        if (!MARKER_EXPORTS.has(imported)) fail('PULSE_SCHEMA_AUTHORING_IMPORT_UNKNOWN', `Unsupported schema marker ${imported}.`, element, record);
+        record.reExports.set(element.name.text, { marker: MARKER_EXPORTS.get(imported) });
+      }
+      return;
+    }
     const resolved = this.resolveRelative(record.file, statement.moduleSpecifier.text, statement.moduleSpecifier, record);
     this.load(resolved);
     if (!statement.exportClause) {
@@ -314,6 +323,7 @@ class TypeGraph {
     const imported = record.imports.get(name);
     if (imported) return this.resolve(this.load(imported.file), imported.name, true, seen);
     const reExport = record.reExports.get(name);
+    if (reExport && reExport.marker) return { record, marker: reExport.marker };
     if (reExport) return this.resolve(this.load(reExport.file), reExport.name, true, seen);
     for (const file of record.exportStars) {
       const resolved = this.resolve(this.load(file), name, true, new Set(seen));
@@ -330,7 +340,7 @@ function classifyType(graph, record, typeNode, state) {
   if (typeNode.kind === ts.SyntaxKind.BooleanKeyword) return Object.freeze({ kind: 'boolean' });
   if (typeNode.kind === ts.SyntaxKind.NumberKeyword) return Object.freeze({ kind: 'f64' });
   if (typeNode.kind === ts.SyntaxKind.UndefinedKeyword || typeNode.kind === ts.SyntaxKind.VoidKeyword) {
-    fail('PULSE_SCHEMA_OPTIONAL_FIELD_RESERVED', 'undefined and optional schema fields are reserved beyond IR v1.', typeNode, record);
+    fail('PULSE_SCHEMA_OPTIONAL_FIELD_RESERVED', 'Explicit undefined schema types are reserved; use a question-mark property for absence.', typeNode, record);
   }
   if (ts.isArrayTypeNode(typeNode)) {
     return Object.freeze({ kind: 'array', element: classifyType(graph, record, typeNode.elementType, state) });
@@ -371,7 +381,18 @@ function classifyType(graph, record, typeNode, state) {
       }
       return Object.freeze({ kind: 'array', element: classifyType(graph, record, typeNode.typeArguments[0], state) });
     }
-    const marker = record.markers.get(name);
+    const resolved = record.markers.has(name) ? undefined : graph.resolve(record, name);
+    const marker = record.markers.get(name) || (resolved && resolved.marker);
+    if (marker === 'open-object') {
+      if (!typeNode.typeArguments || typeNode.typeArguments.length !== 1) {
+        fail('PULSE_SCHEMA_MARKER_GENERIC_UNSUPPORTED', `${name} requires exactly one declared object type.`, typeNode, record);
+      }
+      const object = classifyType(graph, record, typeNode.typeArguments[0], state);
+      if (object.kind !== 'object') {
+        fail('PULSE_SCHEMA_TYPE_UNSUPPORTED', `${name} requires a declared object type.`, typeNode, record);
+      }
+      return Object.freeze({ ...object, additionalProperties: Object.freeze({ kind: 'json-value' }) });
+    }
     if (marker) {
       if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
         fail('PULSE_SCHEMA_MARKER_GENERIC_UNSUPPORTED', `${name} does not accept type arguments.`, typeNode, record);
@@ -383,7 +404,6 @@ function classifyType(graph, record, typeNode, state) {
         typeName: name
       });
     }
-    const resolved = graph.resolve(record, name);
     if (!resolved) {
       fail('PULSE_SCHEMA_TYPE_NOT_FOUND', `Could not resolve schema type ${name}.`, typeNode, record, { typeName: name });
     }
@@ -420,15 +440,7 @@ function classifyMembers(graph, record, members, state) {
     if (!ts.isPropertySignature(member)) {
       fail(
         'PULSE_SCHEMA_OBJECT_MEMBER_UNSUPPORTED',
-        'Schema object types allow required property signatures only.',
-        member,
-        record
-      );
-    }
-    if (member.questionToken) {
-      fail(
-        'PULSE_SCHEMA_OPTIONAL_FIELD_RESERVED',
-        'Optional schema fields are reserved until absence-preserving encode semantics are defined.',
+        'Schema object types allow property signatures only.',
         member,
         record
       );
@@ -444,7 +456,7 @@ function classifyMembers(graph, record, members, state) {
     names.add(name);
     fields.push(Object.freeze({
       name,
-      required: true,
+      required: !member.questionToken,
       value: classifyType(graph, record, member.type, { ...state, node: member }),
       source: sourceLocation(record, member.name)
     }));
@@ -517,10 +529,10 @@ function extractSchemas(graph, record, property) {
     if (ids.has(id)) fail('PULSE_SCHEMA_ID_DUPLICATE', `Schema ID ${id} is declared more than once.`, declaration.name, record, { id });
     ids.add(id);
     const call = helperCall(declaration.initializer, record, 'schema');
-    if (call.arguments.length !== 0 || !call.typeArguments || call.typeArguments.length !== 1) {
+    if (call.arguments.length > 1 || !call.typeArguments || call.typeArguments.length !== 1) {
       fail(
         'PULSE_SCHEMA_DECLARATION_SIGNATURE_INVALID',
-        `Schema ${id} must use schema<Type>() with one type argument and no runtime arguments.`,
+        `Schema ${id} must use schema<Type>() with one type argument and at most one static options object.`,
         call,
         record,
         { id }
@@ -530,7 +542,8 @@ function extractSchemas(graph, record, property) {
     const typeReferenceName = ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)
       ? typeNode.typeName.text
       : null;
-    const resolvedRoot = typeReferenceName ? graph.resolve(record, typeReferenceName) : null;
+    const resolution = typeReferenceName ? graph.resolve(record, typeReferenceName) : null;
+    const resolvedRoot = resolution && resolution.declaration ? resolution : null;
     const typeName = resolvedRoot
       ? resolvedRoot.declaration.name.text
       : `Inline_${id.replace(/[^A-Za-z0-9_$]+/g, '_')}`;
@@ -538,10 +551,27 @@ function extractSchemas(graph, record, property) {
       stack: new Set(),
       node: typeNode
     });
+    let jsonLimits;
+    if (call.arguments.length) {
+      const options = objectProperties(call.arguments[0], record, new Set(['json']), 'schema options');
+      const json = options.properties.get('json');
+      const limits = {};
+      if (json) {
+        const fields = objectProperties(json.initializer, record, new Set(Object.keys(normalizeJsonSchemaLimits())), 'schema JSON limits');
+        for (const [key, property] of fields.properties) {
+          const literal = unwrapExpression(property.initializer);
+          if (!ts.isNumericLiteral(literal)) fail('PULSE_SCHEMA_JSON_LIMIT_LITERAL_REQUIRED', 'Schema JSON limits require positive integer literals.', literal, record);
+          limits[key] = Number(literal.text);
+        }
+      }
+      try { jsonLimits = normalizeJsonSchemaLimits(limits); }
+      catch (error) { fail(error.code, error.message, call.arguments[0], record); }
+    }
     schemas.push(Object.freeze({
       id,
       typeName,
       root,
+      ...(jsonLimits ? { jsonLimits } : {}),
       source: resolvedRoot
         ? sourceLocation(resolvedRoot.record, resolvedRoot.declaration.name)
         : sourceLocation(record, declaration.name)
@@ -621,7 +651,7 @@ function schemaRegistryLegacyBridge(registry) {
   const deferred = [];
   for (const schema of registry.schemas) {
     const fieldPairs = schema.root.fields.map((field) => [field.name, legacyFieldType(field.value)]);
-    if (schema.typeName.startsWith('Inline_') || fieldPairs.some(([, type]) => type === null)) {
+    if (schema.typeName.startsWith('Inline_') || schema.root.fields.some(field => !field.required) || fieldPairs.some(([, type]) => type === null)) {
       deferred.push(schema.id);
       continue;
     }