@pulse-compute/wasm-compiler 1.0.0-beta.7 → 1.0.0-beta.8

package/README.md

@@ -8,9 +8,9 @@
 > **Stability:** Internal compiler interface; no application-author compatibility guarantee.<br>
 > **npm:** [`@pulse-compute/wasm-compiler`](https://www.npmjs.com/package/@pulse-compute/wasm-compiler)<br>
 > **Canonical replacement:** `@pulse-compute/cli`<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.7/packages/implementation-packages/)
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.8/packages/implementation-packages/)
 >
-> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.7` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.8` package policy.
 <!-- pulse-package-status:end -->
 
 Whole-project compiler implementation used by the `pulse` workflow. Application projects should use `@pulse-compute/cli`, not import this package directly.
@@ -63,4 +63,4 @@ The package exports its root implementation plus focused compiler, CLI, extracto
 
 Compiler changes should be covered by focused static/lowering tests, canonical project inspection, provider-plan parity, packed-package discovery where relevant, and the release documentation gates.
 
-See the installed [implementation package guide](https://pulsecompute.io/v1.0.0-beta.7/packages/implementation-packages/) and [compilation concepts](https://pulsecompute.io/v1.0.0-beta.7/concepts/compilation-and-lowering/).
+See the installed [implementation package guide](https://pulsecompute.io/v1.0.0-beta.8/packages/implementation-packages/) and [compilation concepts](https://pulsecompute.io/v1.0.0-beta.8/concepts/compilation-and-lowering/).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pulse-compute/wasm-compiler",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.8",
   "license": "Apache-2.0",
   "description": "PulseWasm compiler package inside the Pulse monorepo.",
   "type": "commonjs",
@@ -9,13 +9,13 @@
     "pulsewasm": "./bin/pulsewasm-extract.js"
   },
   "dependencies": {
-    "@pulse-compute/wasm-build-support": "1.0.0-beta.7",
-    "@pulse-compute/wasm-contracts": "1.0.0-beta.7",
-    "@pulse-compute/wasm-guest-link": "1.0.0-beta.7",
-    "@pulse-compute/wasm-host-runtime": "1.0.0-beta.7",
-    "@pulse-compute/wasm-library-kit": "1.0.0-beta.7",
-    "@pulse-compute/wasm-runtime-core-as": "1.0.0-beta.7",
-    "@pulse-compute/wasm-schema-json": "1.0.0-beta.7",
+    "@pulse-compute/wasm-build-support": "1.0.0-beta.8",
+    "@pulse-compute/wasm-contracts": "1.0.0-beta.8",
+    "@pulse-compute/wasm-guest-link": "1.0.0-beta.8",
+    "@pulse-compute/wasm-host-runtime": "1.0.0-beta.8",
+    "@pulse-compute/wasm-library-kit": "1.0.0-beta.8",
+    "@pulse-compute/wasm-runtime-core-as": "1.0.0-beta.8",
+    "@pulse-compute/wasm-schema-json": "1.0.0-beta.8",
     "assemblyscript": "0.28.18",
     "json-as": "1.5.0",
     "typescript": "5.9.3"
@@ -56,7 +56,7 @@
     "url": "git+https://github.com/pulse-compute/pulse.git",
     "directory": "wasm/packages/compiler"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.7/packages/implementation-packages/",
+  "homepage": "https://pulsecompute.io/v1.0.0-beta.8/packages/implementation-packages/",
   "bugs": {
     "url": "https://github.com/pulse-compute/pulse/issues"
   },

package/src/canonical-native-compiler.js

@@ -221,9 +221,10 @@ function realizeCanonicalNativePlan(plan, options = {}, providerRequirements) {
         '--path', jsonAs.dependencyRoot
       );
     }
+    require('@pulse-compute/wasm-build-support/native-optimization').appendJsonCacheArenaArgs(args, options.elideJsonCacheArena, schemaCodecsActive);
     const readReportCapture = options.reportCapture === false ? () => null : prepareReportCapture(args, stagingDir, generated.manifest,
       require(path.join(asc.packageRoot, 'package.json')).version, 'canonical-native.as/');
-    const startedAt = Date.now();
+    const startedAt = process.hrtime.bigint();
     const result = spawnSync(asc.executable, args, {
       cwd: stagingDir,
       encoding: 'utf8',
@@ -233,7 +234,7 @@ function realizeCanonicalNativePlan(plan, options = {}, providerRequirements) {
         ? { ...process.env, JSON_STRICT: 'true', JSON_USE_FAST_PATH: '0', JSON_MODE: 'NAIVE' }
         : process.env
     });
-    const durationMs = Date.now() - startedAt;
+    const durationMs = Math.round(Number(process.hrtime.bigint() - startedAt) / 1e6);
     if (result.error || result.status !== 0 || !fs.existsSync(wasmFile)) {
       throw new CanonicalNativeCompileError('AssemblyScript failed to compile the canonical native plan.', {
         status: result.status,
@@ -253,9 +254,15 @@ function realizeCanonicalNativePlan(plan, options = {}, providerRequirements) {
       guestUnits,
       generated,
       reportAttribution: readReportCapture(wasm),
+      buildObservation: require('@pulse-compute/wasm-build-support/native-optimization').observeAssemblyScript(args, {
+        version: require(path.join(asc.packageRoot, 'package.json')).version,
+        assemblyScriptRoot: asc.packageRoot, timeoutMs: Number(options.timeoutMs || 120000),
+        compilerVersion: runtimeContract.CANONICAL_NATIVE_COMPILER_VERSION, durationMs, jsonAsVersion: jsonAs && jsonAs.version
+      }),
       wasm,
       wat: emitWat ? fs.readFileSync(watFile, 'utf8') : '',
       textEmitted: emitWat,
+      elideJsonCacheArena: options.elideJsonCacheArena === true,
       assemblyScriptVersion: require(path.join(asc.packageRoot, 'package.json')).version,
       jsonAsVersion: jsonAs && jsonAs.version,
       optimization,
@@ -286,8 +293,9 @@ function verifyCanonicalNativeRealization(realization) {
     compilerVersion: runtimeContract.CANONICAL_NATIVE_COMPILER_VERSION,
     assemblyScript: Object.freeze({ package: 'assemblyscript', version: realization.assemblyScriptVersion }),
     optimization: resolveNativeOptimization(realization.optimization),
+    elideJsonCacheArena: realization.elideJsonCacheArena,
     jsonAs: realization.jsonAsVersion
-      ? Object.freeze({ package: 'json-as', version: realization.jsonAsVersion, transform: true, strict: true, mode: 'NAIVE', fastPath: false })
+      ? Object.freeze({ package: 'json-as', version: realization.jsonAsVersion, transform: true, strict: true, mode: 'NAIVE', fastPath: false, elideDisabledCacheArena: realization.elideJsonCacheArena })
       : null,
     wasm: Object.freeze({ bytes: inspection.bytes, sha256: inspection.sha256, magic: inspection.magic }),
     wat: Object.freeze(realization.textEmitted
@@ -321,6 +329,7 @@ function verifyCanonicalNativeRealization(realization) {
     wat: realization.wat,
     inspection,
     manifest,
+    buildObservation: realization.buildObservation,
     durationMs: realization.durationMs,
     output: realization.output
   });

package/src/canonical-native-plan.js

@@ -1905,6 +1905,7 @@ module.exports = Object.freeze({
   CANONICAL_NATIVE_PLAN_OWNERSHIP_VERSION: contract.CANONICAL_NATIVE_PLAN_OWNERSHIP_VERSION,
   CanonicalNativePlanError,
   buildCanonicalNativePlan,
+  collectCanonicalReportReferences: require('./report-reference-provenance').collectCanonicalReportReferences,
   validateCanonicalNativePlan: assertCanonicalNativePlan,
   writeCanonicalNativePlan,
   stableStringify

package/src/report-reference-provenance.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const { packageOperationRecognitionForCompiled } = require('./spine/package-operation-seam');
+
+// Build-time projection of compiler facts. This record never enters the Native
+// plan, executable source, recipe or provider configuration. Unknown expressions
+// are not evaluated or serialized, and reference resolution is not host binding.
+function collectCanonicalReportReferences(compiled, plan) {
+  const raw = compiled.metadata.applicationEntries || plan.routing?.entries || [];
+  const entries = new Set(raw.map(row => row.stableId));
+  if (!raw.length) entries.add('default');
+  const helpers = new Map(), rows = new Map();
+  const schemas = new Set((compiled.schema?.registry || plan.schemas?.registry)?.schemas?.map(row => row.id) || []);
+  const unique = values => [...new Set(values)].sort();
+  function calls(value, stageConsumers) {
+    if (!value || typeof value !== 'object') return;
+    if (value.kind === 'helper-call' || value.kind === 'pure-helper-call') {
+      if (!helpers.has(value.helperId)) helpers.set(value.helperId, new Set());
+      for (const entry of stageConsumers || [value.callerEntryId]) helpers.get(value.helperId).add(entry);
+    }
+    for (const child of Object.values(value)) if (child && typeof child === 'object') {
+      if (Array.isArray(child)) child.forEach(row => calls(row, stageConsumers)); else calls(child, stageConsumers);
+    }
+  }
+  for (const body of [plan.entry.body, ...(plan.handlers || []).map(row => row.body)]) calls(body);
+  for (const stage of plan.stages || []) calls(stage.body, stage.registrations.map(row => row.entryId));
+  // Package provenance comes from the trusted recognition bundle, never a file
+  // name, schema name or usage-string guess. Keep it outside executable metadata.
+  const packageSources = new Map();
+  const referenceKey = row => JSON.stringify([row.id, row.usage, row.capability,
+    row.file || compiled.metadata.file || '', row.position?.offset]);
+  for (const source of packageOperationRecognitionForCompiled(compiled)?.publicExtensions?.plans || []) {
+    for (const reference of source.schemaReferences || []) {
+      const key = referenceKey(reference);
+      if (!packageSources.has(key)) packageSources.set(key, new Set());
+      packageSources.get(key).add(source.package);
+    }
+  }
+  function owners(effect) {
+    if (effect.helperId) return [...(helpers.get(effect.helperId) || [])];
+    const entry = effect.applicationEntryStableId || effect.routerEntryStableId;
+    return entry ? [entry] : raw.length ? [] : ['default'];
+  }
+  function add(kind, canonicalId, bindingKind, consumers, observationId, detail = {}) {
+    const state = canonicalId === null ? detail.dynamic ? 'dynamic' : 'unknown' : detail.unresolved ? 'unknown' : 'resolved';
+    const key = JSON.stringify([kind, bindingKind, state, state === 'resolved' ? canonicalId : observationId]);
+    let row = rows.get(key);
+    if (!row) {
+      row = { kind, canonicalId, bindingKind, state, observationId: state === 'resolved' ? null : observationId,
+        entryIds: [], entriesComplete: true, ...(detail.resource ? { resource: detail.resource } : {}) };
+      rows.set(key, row);
+    }
+    row.entryIds.push(...consumers.filter(id => entries.has(id)));
+    row.entriesComplete &&= consumers.length > 0 && consumers.every(id => entries.has(id));
+    if (detail.externalPackages?.length) row.externalPackages = unique([...(row.externalPackages || []), ...detail.externalPackages]);
+  }
+  const literal = value => value?.kind === 'literal' && typeof value.value === 'string' ? value.value : null;
+  const input = (effect, name) => effect.inputs?.find(row => row.name === name)?.value;
+  const field = (object, name) => object?.kind === 'object'
+    ? object.entries?.find(row => row.key?.kind === 'literal' && row.key.value === name)?.value : null;
+  for (const effect of plan.effects || []) {
+    const consumers = owners(effect), kind = effect.providerKind;
+    if (['config', 'secret', 'kv', 's3'].includes(kind)) {
+      const expression = kind === 's3' ? field(input(effect, 'resource'), 'binding')
+        : input(effect, kind === 'kv' ? 'store' : 'name');
+      const resolved = literal(expression);
+      const name = resolved ?? (effect.resource?.kind === 'literal' && typeof effect.resource.value === 'string' ? effect.resource.value : null);
+      add('binding', name, kind, consumers, effect.id, {
+        dynamic: effect.resource?.kind === 'dynamic' || Boolean(expression && expression.kind !== 'literal')
+      });
+    }
+    if (effect.kind === 'event.emit') {
+      const schema = literal(field(input(effect, 'emission'), 'schema'));
+      if (schema !== null) add('schema', schema, null, consumers, effect.id, { unresolved: !schemas.has(schema) });
+    }
+    if (effect.kind !== 'assets.lookup') continue;
+    const payload = input(effect, 'payload'), embeddedId = literal(field(payload, 'embeddedId'));
+    const key = literal(field(payload, 'key'));
+    const found = field(payload, 'embeddedFound')?.value === true;
+    const bytes = field(payload, 'embeddedLength')?.value;
+    const encoded = literal(field(payload, 'embeddedData'));
+    const known = embeddedId !== null && key !== null && found && Number.isSafeInteger(bytes) && bytes >= 0;
+    add('resource', embeddedId !== null && key !== null ? embeddedId + ':' + key : null, null, consumers, effect.id, {
+      unresolved: !known,
+      dynamic: Boolean(field(payload, 'key') && field(payload, 'key').kind !== 'literal'),
+      ...(known ? { resource: { name: key, mediaType: literal(field(payload, 'embeddedType')), inputBytes: bytes,
+        encodedBytes: encoded === null ? null : Buffer.byteLength(encoded, 'utf8') } } : {})
+    });
+  }
+  // These offsets are compiler-generated entry/helper ranges, not a reader's source
+  // heuristic. Authored package references from another file cannot borrow an
+  // unrelated generated offset. Unassociated references remain observations.
+  for (const [index, reference] of (compiled.metadata.schemaReferences || []).entries()) {
+    const sameFile = !reference.file || reference.file === compiled.metadata.file;
+    const offset = reference.position?.offset;
+    const contains = row => row.generatedRange && offset >= row.generatedRange.start && offset < row.generatedRange.end;
+    const located = sameFile && Number.isSafeInteger(offset);
+    const matches = located ? raw.filter(contains) : [];
+    const helperMatches = located ? (plan.routing?.helpers || []).filter(contains) : [];
+    const consumers = !raw.length && sameFile ? ['default']
+      : matches.length === 1 && !helperMatches.length ? [matches[0].stableId]
+      : !matches.length && helperMatches.length === 1 ? [...(helpers.get(helperMatches[0].id) || [])] : [];
+    const name = typeof reference.id === 'string' && reference.id ? reference.id : null;
+    add('schema', name, null, consumers, 'schema:' + index, { unresolved: !schemas.has(name),
+      externalPackages: [...(packageSources.get(referenceKey(reference)) || [])] });
+  }
+  for (const event of compiled.eventCatalog?.events || []) if (event.schemaId) {
+    add('schema', event.schemaId, null, [event.stableId], event.stableId, { unresolved: !schemas.has(event.schemaId) });
+  }
+  // Only compact allowlisted data crosses into Report. No provider metadata,
+  // effect payloads, binding values, resource bodies or expression text survives.
+  const routeBehaviors = require('./report-route-behavior').routeBehaviorForMetadata(compiled.metadata.router);
+  return Object.freeze({ version: 'pulse.compiler-report-references.v1',
+    ...(routeBehaviors ? { routeBehaviors } : {}),
+    responsePayloads: require('./report-response-payloads').collectResponsePayloads(plan, entries, helpers),
+    references: Object.freeze([...rows.values()].map(row => Object.freeze({ ...row, entryIds: Object.freeze(unique(row.entryIds)),
+      ...(row.externalPackages ? { externalPackages: Object.freeze(row.externalPackages) } : {}),
+      ...(row.resource ? { resource: Object.freeze(row.resource) } : {}) }))) });
+}
+
+module.exports = { collectCanonicalReportReferences };

package/src/report-response-payloads.js

@@ -0,0 +1,62 @@
+'use strict';
+
+// Observational projection of canonical text-response sites, after emission.
+// Never evaluate application expressions or expose literal contents/hashes.
+function collectResponsePayloads(plan, entryIds, helperConsumers) {
+  const sites = [];
+  const unique = values => [...new Set(values)].sort();
+  const literal = value => value?.kind === 'literal' && typeof value.value === 'string' ? value.value : null;
+  const objectFields = value => value?.kind === 'object' && value.entries.every(row => row.kind === 'property'
+    && row.key?.kind === 'literal' && typeof row.key.value === 'string') ? value.entries : null;
+  const field = (rows, key) => rows?.filter(row => row.key.value === key).at(-1)?.value;
+  function mediaType(options) {
+    if (!options || options.kind === 'undefined') return 'text/plain';
+    const fields = objectFields(options);
+    if (!fields) return null;
+    const headers = field(fields, 'headers');
+    if (!headers) return 'text/plain';
+    const values = objectFields(headers);
+    if (!values) return null;
+    const types = values.filter(row => row.key.value.toLowerCase() === 'content-type');
+    if (!types.length) return 'text/plain';
+    // Case variants can be merged by the runtime header adapter; do not guess.
+    if (types.length !== 1) return null;
+    const type = literal(types[0].value)?.split(';')[0].trim().toLowerCase();
+    return ['text/plain', 'text/css', 'text/html', 'text/javascript', 'application/javascript'].includes(type) ? type : null;
+  }
+  function scan(body, owner, consumers) {
+    const constants = new Map();
+    function visit(value, fn, path = 'body') {
+      if (!value || typeof value !== 'object') return;
+      fn(value, path);
+      for (const [key, child] of Object.entries(value)) if (child && typeof child === 'object') {
+        if (Array.isArray(child)) child.forEach((row, i) => visit(row, fn, path + '.' + key + '[' + i + ']'));
+        else visit(child, fn, path + '.' + key);
+      }
+    }
+    visit(body, node => {
+      if (node.kind === 'local' && node.declaration === 'const' && literal(node.value) !== null)
+        constants.set(node.localId, node.value.value);
+    });
+    visit(body, (node, path) => {
+      if (node.kind !== 'intrinsic' || node.name !== 'response.text') return;
+      const input = node.arguments[0];
+      const value = literal(input) ?? (input?.kind === 'local' ? constants.get(input.id) : null);
+      const known = typeof value === 'string';
+      const state = known ? 'resolved' : !input || ['literal', 'undefined'].includes(input.kind) ? 'unknown' : 'dynamic';
+      const valid = unique(consumers.filter(id => entryIds.has(id)));
+      sites.push(Object.freeze({ canonicalId: JSON.stringify([owner, path]),
+        state, inputBytes: known ? Buffer.byteLength(value, 'utf8') : null,
+        mediaType: mediaType(node.arguments[1]), entryIds: Object.freeze(valid),
+        entriesComplete: consumers.length > 0 && consumers.every(id => entryIds.has(id)) }));
+    });
+  }
+  scan(plan.entry.body, 'entry', plan.entry.kind === 'router' ? [] : ['default']);
+  for (const row of plan.handlers || []) scan(row.body, 'handler:' + row.id, [row.id]);
+  for (const row of plan.stages || []) scan(row.body, 'stage:' + row.id, row.registrations.map(item => item.entryId));
+  for (const row of plan.helpers || []) scan(row.body, 'helper:' + row.id, [...(helperConsumers.get(row.id) || [])]);
+  sites.sort((a, b) => a.canonicalId < b.canonicalId ? -1 : a.canonicalId > b.canonicalId ? 1 : 0);
+  return Object.freeze({ version: 'pulse.report-text-responses.v1', sites: Object.freeze(sites) });
+}
+
+module.exports = { collectResponsePayloads };

package/src/report-route-behavior.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Observational only: keep IR facts out of serialized compiler metadata, source
+// and plan hashes. A deserialized/foreign metadata object supplies no evidence.
+const records = new WeakMap();
+function retainRouteBehavior(metadata, handlers) {
+  const routes = new Set(metadata.entries.filter(row => row.kind === 'route').map(row => row.stableId));
+  records.set(metadata, Object.freeze(handlers.filter(row => routes.has(row.entryStableId)).map(row => Object.freeze({
+    entryId: row.entryStableId,
+    kind: row.operationIr.summary.operationKinds['router-transfer'] ? 'continuing' : 'terminal',
+    basis: 'canonical-handler-ir'
+  }))));
+}
+function routeBehaviorForMetadata(metadata) { return records.get(metadata); }
+module.exports = { retainRouteBehavior, routeBehaviorForMetadata };

package/src/spine/canonical-router.js

@@ -118,6 +118,7 @@ function executeCanonicalRouterSpine(sourceText, options = {}) {
   if (output && typeof output === 'object') {
     traces.set(output, result.trace);
     handlerIrBundles.set(output, bundle.handlers);
+    require('../report-route-behavior').retainRouteBehavior(output.metadata, bundle.handlers);
     surfaceFacts.set(output, Object.freeze({
       recognition: bundle.recognition,
       classification: bundle.classification,