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

package/src/spine/pure-helper-source.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const ts = require('typescript');
+const values = require('../pure-helper-values');
+
+// Admission only; lowering remains in Handler IR and the canonical plan.
+function validatePureHelperSource(helper) {
+  const fn = helper.functionNode, source = helper.sourceFile, diagnostics = [];
+  const scalar = node => node && values.scalar(ts.tokenToString(node.kind));
+  helper.parameterTypes = fn.parameters.map(p => helper.resolveType?.(p.type) || (scalar(p.type) ? p.type.getText(source) : undefined));
+  function fail(node, reason, message) {
+    const pos = source.getLineAndCharacterOfPosition(node.getStart(source));
+    diagnostics.push({ code: `PULSE_NATIVE_PURE_HELPER_${reason}_UNSUPPORTED`, severity: 'error', message,
+      file: helper.source.file, position: { line: pos.line + 1, column: pos.character + 1 } });
+  }
+  if (!ts.isFunctionDeclaration(fn) || fn.asteriskToken || fn.typeParameters?.length || !fn.body || !ts.isBlock(fn.body)
+    || fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || !scalar(fn.type)
+    || fn.parameters.some(p => !ts.isIdentifier(p.name) || p.name.text === 'ctx' || !helper.parameterTypes[fn.parameters.indexOf(p)] || p.initializer || p.dotDotDotToken || p.questionToken)
+    || new Set(fn.parameters.map(p => p.name.getText(source))).size !== fn.parameters.length) {
+    fail(fn, 'SIGNATURE', 'Pure helpers require synchronous function declarations with explicit bounded scalar/record/number-array parameters and a scalar result.');
+    return diagnostics;
+  }
+  // Function declarations are mutable bindings in JS; reject writes anywhere in
+  // the defining module. Caller shadowing is checked at the resolved call site.
+  function assignments(node) {
+    const target = ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+      ? node.left : (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) ? node.operand : undefined;
+    if (target && ts.isIdentifier(target) && target.text === fn.name.text) fail(node, 'IDENTITY', 'Pure helper identities cannot be reassigned.');
+    ts.forEachChild(node, assignments);
+  }
+  assignments(source);
+  const params = new Set(fn.parameters.map(p => p.name.text));
+  const names = new Set(params);
+  function collect(node) {
+    if (node !== fn && ts.isFunctionLike(node)) { fail(node, 'CAPTURE', 'Nested functions and closures are outside pure helpers.'); return; }
+    if (ts.isVariableDeclaration(node)) {
+      if (!ts.isIdentifier(node.name) || names.has(node.name.text)) fail(node, 'LOCAL', 'Pure helper locals must have unique identifier bindings.');
+      else names.add(node.name.text);
+    }
+    ts.forEachChild(node, collect);
+  }
+  collect(fn.body);
+  function inspect(node) {
+    if (ts.isCallExpression(node)) { fail(node, 'CALL', 'Pure helpers cannot call helpers, callbacks, methods, effects or Router operations.'); return; }
+    if (ts.isAwaitExpression(node) || ts.isYieldExpression(node) || ts.isThrowStatement(node) || ts.isTryStatement(node)) {
+      fail(node, 'CONTROL', 'Async operations and exception syntax are outside pure helpers.'); return;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+      if (node.questionDotToken) fail(node, 'SHAPE', 'Optional access is outside pure helpers.');
+      inspect(node.expression); return;
+    }
+    if (ts.isElementAccessExpression(node)) {
+      if (node.questionDotToken) fail(node, 'SHAPE', 'Optional access is outside pure helpers.');
+      inspect(node.expression); inspect(node.argumentExpression); return;
+    }
+    if (ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node)
+      || ts.isNewExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isNonNullExpression(node)) {
+      fail(node, 'VALUE', 'Pure helpers cannot allocate structured values or use type assertions.'); return;
+    }
+    if (ts.isIdentifier(node) && !names.has(node.text)) fail(node, 'CAPTURE', `Pure helper cannot capture ${node.text}.`);
+    const target = ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+      ? node.left : ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator)) ? node.operand : undefined;
+    if (target && (!ts.isIdentifier(target) || params.has(target.text))) fail(node, 'MUTATION', 'Pure helper parameters are read-only.');
+    if (ts.isVariableDeclaration(node)) {
+      if (!node.initializer || node.type && !scalar(node.type) && !helper.resolveType?.(node.type)) fail(node, 'LOCAL', 'Pure helper locals require supported initializers.');
+      if (node.initializer) inspect(node.initializer);
+      return;
+    }
+    ts.forEachChild(node, inspect);
+  }
+  inspect(fn.body);
+  return diagnostics;
+}
+// Resolve only structural declarations in the already contained project graph.
+// No TypeScript checker widening, ambient types, package lookup or runtime import.
+function resolvePureType(context, module, node, seen = new Set(), depth = 0) {
+  if (!node || depth > values.BORROW_LIMITS.recordDepth) return;
+  if (values.scalar(ts.tokenToString(node.kind))) return node.getText(module.sourceFile);
+  if (ts.isArrayTypeNode(node) && node.elementType.kind === ts.SyntaxKind.NumberKeyword) return { kind: 'number-array' };
+  if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && !node.typeArguments?.length) {
+    const name = node.typeName.text, key = module.path + '#' + name;
+    if (seen.has(key)) return;
+    const next = new Set([...seen, key]);
+    const declarations = module.sourceFile.statements.filter(s => (ts.isInterfaceDeclaration(s) || ts.isTypeAliasDeclaration(s)) && s.name.text === name);
+    if (declarations.length === 1) {
+      const decl = declarations[0];
+      if (decl.typeParameters?.length || decl.heritageClauses?.length) return;
+      return resolvePureType(context, module, ts.isTypeAliasDeclaration(decl) ? decl.type : decl, next, depth);
+    }
+    for (const relation of module.imports) {
+      const binding = relation.bindings.find(b => b.localName === name);
+      if (!binding || binding.importedName === '*') continue;
+      const resolution = module.resolutions.find(r => r.relation === relation);
+      const target = resolution && context.projectModules.get(resolution.targetKey);
+      if (!target) return;
+      const exported = target.sourceFile.statements.find(s => (ts.isInterfaceDeclaration(s) || ts.isTypeAliasDeclaration(s)) && s.name.text === binding.importedName && s.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword));
+      const targetName = target.localExports.get(binding.importedName) || exported?.name.text;
+      if (!targetName) return;
+      const decl = target.sourceFile.statements.find(s => (ts.isInterfaceDeclaration(s) || ts.isTypeAliasDeclaration(s)) && s.name.text === targetName);
+      if (!decl || decl.typeParameters?.length || decl.heritageClauses?.length) return;
+      return resolvePureType(context, target, ts.isTypeAliasDeclaration(decl) ? decl.type : decl, next, depth);
+    }
+    return;
+  }
+  if ((ts.isInterfaceDeclaration(node) || ts.isTypeLiteralNode(node)) && depth < values.BORROW_LIMITS.recordDepth) {
+    const fields = [];
+    for (const member of node.members) {
+      if (!ts.isPropertySignature(member) || !ts.isIdentifier(member.name) || member.questionToken || member.initializer) return;
+      const name = member.name.text;
+      if (values.FORBIDDEN_FIELDS.includes(name) || fields.some(f => f.name === name)) return;
+      const type = resolvePureType(context, module, member.type, seen, depth + 1);
+      if (!type) return;
+      fields.push({ name, type });
+    }
+    if (fields.length && fields.length <= values.BORROW_LIMITS.recordFields) return { kind: 'record', fields };
+  }
+}
+function typeNode(type) {
+  if (typeof type === 'string') return ts.factory.createKeywordTypeNode({string:ts.SyntaxKind.StringKeyword,number:ts.SyntaxKind.NumberKeyword,boolean:ts.SyntaxKind.BooleanKeyword}[type]);
+  if (type.kind === 'number-array') return ts.factory.createArrayTypeNode(typeNode('number'));
+  return ts.factory.createTypeLiteralNode(type.fields.map(f => ts.factory.createPropertySignature(undefined, f.name, undefined, typeNode(f.type))));
+}
+module.exports = { validatePureHelperSource, resolvePureType, typeNode };

package/src/spine/router-handler-frontend.js

@@ -130,6 +130,7 @@ function analysisForSurfaceFacts(surfaceFacts) {
   const capabilities = new Set();
   let fetchCount = 0;
   for (const fact of facts) {
+    if (fact.surfaceId === 'ctx.req.body') { capabilities.add('request.body.forward'); continue; }
     if (fact.surfaceId.startsWith('ctx.fetch.')) { capabilities.add('fetch'); fetchCount += 1; continue; }
     if (fact.surfaceId.startsWith('ctx.req.')) capabilities.add(fact.surfaceId.slice('ctx.'.length));
     else if (fact.surfaceId.startsWith('ctx.config.')) capabilities.add('config.get');
@@ -197,6 +198,7 @@ function normalizeRouterHandler(topology, descriptor, recognition, classificatio
     handlerAuthoring: topology.options && topology.options.handlerAuthoring,
     requireAsync: topology.options && topology.options.requireAsync === true,
     requireEffectAwait: topology.options && topology.options.requireEffectAwait === true,
+    helperForCall: topology.options?.linkedProjectModules?.helperForCall,
     packageEffectForCall: topology.options && topology.options.packageEffectForCall
       || ((call) => packageEffectsByStart.get(call.getStart(sourceFile)))
   });
@@ -230,7 +232,7 @@ function normalizeRouterHandler(topology, descriptor, recognition, classificatio
     }
     const contextSurface = recognizeHandlerSurface(node, { ctxName, unwrap: true });
     if (contextSurface) {
-      const httpOnly = contextSurface.surfaceId === 'ctx.param'
+      const httpOnly = contextSurface.surfaceId.startsWith('ctx.output.') || contextSurface.surfaceId === 'ctx.param'
         || contextSurface.surfaceId.startsWith('ctx.req.')
         || ['ctx.json', 'ctx.text', 'ctx.response'].includes(contextSurface.surfaceId);
       const eventOnly = contextSurface.surfaceId.startsWith('ctx.event.');
@@ -258,6 +260,41 @@ function normalizeRouterHandler(topology, descriptor, recognition, classificatio
 
   const rewriteTransformer = (context) => {
     const visit = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)
+        && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === ctxName
+        && node.expression.name.text === 'kv' && node.typeArguments?.length === 1) {
+        const type = topology.options?.linkedProjectModules?.pureTypeForNode?.(node.typeArguments[0]);
+        if (type) return ts.factory.updateCallExpression(node, node.expression,
+          [require('./pure-helper-source').typeNode(type)], node.arguments.map(arg => ts.visitNode(arg, visit)));
+      }
+      const helper = ts.isCallExpression(node) && topology.options?.linkedProjectModules?.helperForCall?.(node);
+      if (helper) {
+        const original = ts.getOriginalNode(node);
+        const awaited = original.parent && ts.isAwaitExpression(original.parent);
+        const binding = awaited && original.parent.parent;
+        let shadowed = false;
+        const inspect = item => {
+          if ((ts.isVariableDeclaration(item) || ts.isParameter(item) || ts.isFunctionDeclaration(item)) && ts.isIdentifier(item.name) && item.name.text === original.expression.text) shadowed = true;
+          ts.forEachChild(item, inspect);
+        };
+        inspect(authoredFunctionNode);
+        if (helper.pure) {
+          if (awaited || shadowed || node.typeArguments?.length || node.questionDotToken
+            || node.arguments.length !== helper.functionNode.parameters.length || !['route', 'middleware'].includes(role)) {
+            diagnostics.push(diagnostic(sourceFile, original, 'PULSE_NATIVE_PURE_HELPER_CALL_UNSUPPORTED',
+              'Pure helpers require a static unshadowed synchronous pure call in an HTTP handler.'));
+          }
+          return ts.factory.updateCallExpression(node, ts.factory.createIdentifier(helper.name), undefined,
+            node.arguments.map(arg => ts.visitNode(arg, visit)));
+        }
+        if (!binding || !ts.isVariableDeclaration(binding) || !ts.isIdentifier(binding.name)
+          || shadowed || node.arguments.length !== helper.functionNode.parameters.length
+          || !ts.isIdentifier(node.arguments[0]) || node.arguments[0].text !== ctxName
+          || !['route', 'middleware'].includes(role)) {
+          diagnostics.push(diagnostic(sourceFile, original, 'PULSE_NATIVE_HELPER_CALL_UNSUPPORTED', 'A source helper requires an unshadowed, directly awaited local binding and the current request context in an HTTP handler.'));
+        }
+        return ts.factory.updateCallExpression(node, ts.factory.createIdentifier(helper.name), undefined, node.arguments.slice(1));
+      }
       if (errorName && ts.isShorthandPropertyAssignment(node) && node.name.text === errorName) {
         return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(errorName), ts.factory.createIdentifier(ERROR));
       }

package/src/spine/router-handler-ir.js

@@ -1,4 +1,7 @@
 'use strict';
+const ts = require('typescript');
+const { normalizeManagedHandler } = require('./async-surface-normalizer');
+const { CanonicalRouterCompileError } = require('./router-topology-frontend');
 
 const {
   buildRouterHandlerIr
@@ -142,15 +145,73 @@ function emitCanonicalRouterFromHandlerIrs(prepared) {
   const topology = prepared.topology;
   const operationByEntry = new Map();
   const emittedByEntry = new Map();
+  const bodyByEntry = new Map();
+  const authoredHandlers = new Map(topology.handlerTable.handlers.map(handler => [handler.id, handler]));
   for (const handler of prepared.handlers) {
     const operationIr = buildRouterHandlerIr(handler);
     operationByEntry.set(handler.entry.stableId, operationIr);
     emittedByEntry.set(handler.entry.stableId, emitCanonicalRouterHandlerBody(operationIr));
+    // The first private body family is a terminal HTTP route. Transfer-capable
+    // handlers retain the existing cursor/mode lowering until their own pass.
+    if (handler.entry.kind === 'route' && !operationIr.summary.operationKinds['router-transfer']) {
+      const authored = authoredHandlers.get(handler.entry.handlerId);
+      bodyByEntry.set(handler.entry.stableId, Object.freeze({
+        version: 'pulse.router-native-body.v1',
+        family: 'terminal-route',
+        name: `__pulse_body_${handler.entry.stableId}`,
+        source: authored && authored.loc
+      }));
+    }
   }
 
   const header = topology.retainedDeclarations;
   let synthetic = header ? `${header}\n\n` : '';
   synthetic += 'export default function __pulse_router_entry(ctx) {\n';
+  const helpers = [];
+  const helperRecords = [];
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  for (const helper of topology.options?.linkedProjectModules?.sourceHelpers || []) {
+    const fn = helper.functionNode;
+    if (helper.pure) {
+      const diagnostics = require('./pure-helper-source').validatePureHelperSource(helper);
+      if (diagnostics.length) throw new CanonicalRouterCompileError('Unsupported pure source helper.', diagnostics);
+      const start = synthetic.length;
+      synthetic += `function ${helper.name}(${fn.parameters.map(p => printer.printNode(ts.EmitHint.Unspecified, p, helper.sourceFile)).join(',')}) ${printer.printNode(ts.EmitHint.Unspecified, fn.body, helper.sourceFile)}\n`;
+      const generatedRange = { start, end: synthetic.length };
+      helpers.push({ id: helper.id, name: helper.name, pure: true, source: helper.source,
+        resultKind: fn.type.getText(helper.sourceFile),
+        parameters: fn.parameters.map((p, i) => { const type = helper.parameterTypes[i]; return { name: p.name.text, valueKind: typeof type === 'string' ? type : type.kind === 'record' ? 'object' : 'array', ...(typeof type === 'object' ? { borrow: { version: require('@pulse-compute/wasm-contracts/handler/canonical-native-plan').CANONICAL_NATIVE_PURE_BORROW_VERSION, type } } : {}) }; }), generatedRange });
+      helperRecords.push({ entryStableId: helper.id, operationIr: { sourceFile: helper.sourceFile, handler: fn },
+        canonicalIr: { router: { entry: { generatedRange } } } });
+      continue;
+    }
+    const declaration = fn.parent;
+    const immutable = !ts.isVariableDeclaration(declaration) || Boolean(declaration.parent.flags & ts.NodeFlags.Const);
+    let reassigned = false;
+    const scanAssignments = node => {
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+        && ts.isIdentifier(node.left) && node.left.text === helper.source.name) reassigned = true;
+      ts.forEachChild(node, scanAssignments);
+    };
+    scanAssignments(helper.sourceFile);
+    const valid = immutable && !reassigned && ts.isBlock(fn.body) && fn.parameters[0]?.name?.text === 'ctx'
+      && fn.parameters.every((p, i) => ts.isIdentifier(p.name) && !p.initializer && !p.dotDotDotToken && !p.questionToken
+        && (i === 0 || [ts.SyntaxKind.StringKeyword, ts.SyntaxKind.NumberKeyword, ts.SyntaxKind.BooleanKeyword].includes(p.type?.kind)))
+      && new Set(fn.parameters.map(p => p.name.text)).size === fn.parameters.length
+      && fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword);
+    if (!valid) throw new CanonicalRouterCompileError('Unsupported source helper signature.', [{ code: 'PULSE_NATIVE_HELPER_SIGNATURE_UNSUPPORTED', severity: 'error', message: 'Helpers require async block bodies, ctx first and explicit scalar inputs.', file: helper.source.file }]);
+    const normalized = normalizeManagedHandler(fn, { sourceFile: helper.sourceFile, ctxName: 'ctx', frontend: 'canonical-router',
+      target: 'native', requireAsync: true, packageEffectForCall: topology.options.packageEffectForCall });
+    if (normalized.diagnostics.length) throw new CanonicalRouterCompileError('Unsupported source helper body.', normalized.diagnostics);
+    const start = synthetic.length;
+    const parameters = fn.parameters.slice(1).map(p => printer.printNode(ts.EmitHint.Unspecified, p, helper.sourceFile)).join(',');
+    synthetic += `function ${helper.name}(${parameters}) ${printer.printNode(ts.EmitHint.Unspecified, normalized.functionNode.body, helper.sourceFile)}\n`;
+    const generatedRange = { start, end: synthetic.length };
+    helpers.push({ id: helper.id, name: helper.name, source: helper.source,
+      parameters: fn.parameters.slice(1).map(p => ({ name: p.name.text, valueKind: p.type.getText(helper.sourceFile) })), generatedRange });
+    helperRecords.push({ entryStableId: helper.id, operationIr: { sourceFile: helper.sourceFile, handler: fn },
+      canonicalIr: { router: { entry: { generatedRange } } } });
+  }
 
   const eventReachable = Boolean(topology.eventTopology && topology.eventCatalog && topology.eventCatalog.events.length > 0);
   const eventTopology = realizedEventTopology(topology, prepared);
@@ -198,7 +259,9 @@ function emitCanonicalRouterFromHandlerIrs(prepared) {
 
     if (entry.kind === 'mount') {
       const pattern = rawEntry.pattern && rawEntry.pattern.normalized || `${rawEntry.path || '/'}/*`;
-      synthetic += `    if (${MODE} === 0 && __pulse_router_match(ctx.req.path, ${JSON.stringify(pattern)})) {\n`;
+      const eligibility = rawEntry.eligibility;
+      const condition = eligibility ? ` && ctx.state.get(${JSON.stringify(eligibility.state)}) === ${JSON.stringify(eligibility.equals)}` : '';
+      synthetic += `    if (${MODE} === 0 && __pulse_router_match(ctx.req.path, ${JSON.stringify(pattern)})${condition}) {\n`;
       synthetic += `      ${CURSOR} = ${rawEntry.childStartIndex};\n`;
       synthetic += '    } else {\n';
       synthetic += `      ${CURSOR} = ${rawEntry.parentContinueIndex};\n`;
@@ -213,10 +276,13 @@ function emitCanonicalRouterFromHandlerIrs(prepared) {
       }
       if (entry.kind === 'route') matchCondition += ` && ctx.req.method === ${JSON.stringify(entry.method)} && __pulse_router_match(ctx.req.path, ${JSON.stringify(entry.path)})`;
       synthetic += `    if (${matchCondition}) {\n`;
+      const nativeBody = bodyByEntry.get(entry.stableId);
+      if (nativeBody) synthetic += `      function ${nativeBody.name}() {\n`;
       const start = synthetic.length;
-      synthetic += `${indent(emitted.sourceText, 6)}\n`;
+      synthetic += `${indent(emitted.sourceText, nativeBody ? 8 : 6)}\n`;
       const end = synthetic.length;
       generatedRange = Object.freeze({ start, end });
+      if (nativeBody) synthetic += `      }\n      return ${nativeBody.name}();\n`;
       synthetic += '    } else {\n';
       synthetic += `      ${CURSOR} = ${entry.nextIndex};\n`;
       synthetic += '    }\n';
@@ -227,6 +293,7 @@ function emitCanonicalRouterFromHandlerIrs(prepared) {
 
     const record = Object.freeze({
       ...entry,
+      ...(bodyByEntry.has(entry.stableId) ? { nativeBody: bodyByEntry.get(entry.stableId) } : {}),
       ...(eventReachable ? { plane: 'http' } : {}),
       generatedRange,
       generatedBlockRange: Object.freeze({ start: openingStart, end: synthetic.length })
@@ -354,6 +421,7 @@ function emitCanonicalRouterFromHandlerIrs(prepared) {
       }),
       routes: Object.freeze(routeRecords),
       entries: Object.freeze(entryRecords),
+      ...(helpers.length ? { helpers: Object.freeze(helpers) } : {}),
       ...(eventReachable ? { applicationEntries: Object.freeze(entryRecords) } : {})
     }),
     diagnostics: Object.freeze([])
@@ -362,7 +430,7 @@ function emitCanonicalRouterFromHandlerIrs(prepared) {
   return Object.freeze({
     version: ROUTER_HANDLER_IR_BUNDLE_VERSION,
     output,
-    handlers: Object.freeze(handlerRecords)
+    handlers: Object.freeze([...helperRecords, ...handlerRecords])
   });
 }
 

package/src/spine/router-topology-frontend.js

@@ -188,7 +188,8 @@ function stableEntryId(entry) {
     method: entry.method,
     path: entry.path,
     handlerId: entry.handler && (entry.handler.id || entry.handler.handlerId),
-    childRouter: entry.childRouter
+    childRouter: entry.childRouter,
+    ...(entry.eligibility ? { eligibility: entry.eligibility } : {})
   });
   return `router_entry_${crypto.createHash('sha256').update(input).digest('hex').slice(0, 24)}`;
 }
@@ -233,6 +234,7 @@ function cleanExecutionEntry(entry) {
     routeRuntimeId: Number.isInteger(entry.runtimeId) ? entry.runtimeId : undefined,
     handlerId: entry.handler && (entry.handler.id || entry.handler.handlerId) || undefined,
     childRouter: entry.childRouter || undefined,
+    ...(entry.eligibility ? { eligibility: Object.freeze({ ...entry.eligibility }) } : {}),
     childStartIndex: Number.isInteger(entry.childStartIndex) ? entry.childStartIndex : undefined,
     parentContinueIndex: Number.isInteger(entry.parentContinueIndex) ? entry.parentContinueIndex : undefined
   });

package/src/spine/terminal-package-native.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { findLowerableManifestRecord } = require('@pulse-compute/wasm-library-kit/compiler/package-lowering');
+const { loadLowerableCompilerBuilder } = require('@pulse-compute/wasm-library-kit/compiler/handler-library-contracts');
+const { compileManagedHandlerNativeBundle } = require('./handler-ir-managed.js');
+const applications = new WeakMap();
+
+function attachTerminalPackageNative(compiled, inputs) {
+  applications.set(compiled, inputs);
+}
+
+function terminalPackageNativeForCompiled(compiled) {
+  const inputs = applications.get(compiled);
+  if (!inputs) return null;
+  const { application, recognition, managedHandlers, schemaBundle, cwd, workspaceRoot } = inputs;
+  const selected = recognition.packages.find(entry => entry.contractId === application.contractId);
+  if (!selected || selected.builder.trust !== 'first-party') throw new TypeError('Native application requires its selected trusted lowerer.');
+  const { record } = findLowerableManifestRecord({ cwd, workspaceRoot, contractId: selected.contractId, npmPackage: selected.package });
+  const exportName = record?.manifest?.compiler?.nativeApplicationExport;
+  if (!exportName) return null;
+  const loaded = loadLowerableCompilerBuilder(record);
+  const builder = Object.hasOwn(loaded.module, exportName) ? loaded.module[exportName] : null;
+  if (typeof builder !== 'function') throw new TypeError('Trusted Native application builder is missing.');
+  const intrinsic = recognition.intrinsics.find(entry => entry.intrinsic === application.intrinsic);
+  const result = builder({
+    plan: intrinsic.staticArguments[0],
+    managedHandlerNativeBundle: compileManagedHandlerNativeBundle(managedHandlers),
+    schemaBundle
+  });
+  if (result.version !== 'pulse.package-native-application.v1' || result.contractId !== selected.contractId
+    || result.package !== selected.package || result.intrinsic !== application.intrinsic || result.automaticFallback !== false) {
+    throw new TypeError('Trusted Native application result does not match its selected package.');
+  }
+  return result;
+}
+
+module.exports = { attachTerminalPackageNative, terminalPackageNativeForCompiled };