@pulse-compute/wasm-compiler 0.0.0 → 1.0.0-beta.1

package/src/handler-table.js

@@ -0,0 +1,326 @@
+'use strict';
+
+const { PACKAGE_VERSION, normalizeArtifact, stableFileName } = require('./diagnostics.js');
+const { createHandlerStableId, createHandlerStableInput } = require('./stable-id.js');
+const { DEFAULT_HANDLER_ROLE_REGISTRY, ROLE_SIGNATURES, roleForOperation } = require('./definitions/handler-roles.js');
+const { HANDLER_ID_POLICY, HANDLER_TABLE_VERSION } = loadContractsHandlerTable();
+const EVENT_ROLE_SIGNATURE = Object.freeze({ params: 1, display: '(ctx) => Promise<void>' });
+
+function loadContractsHandlerTable() {
+  try {
+    return require('@pulse-compute/wasm-contracts/handler-table');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../contracts/src/handler-table.js');
+    }
+    throw error;
+  }
+}
+
+function clone(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function uniqueSorted(values) {
+  return Array.from(new Set(values)).sort();
+}
+
+function handlerDisplayName(entry) {
+  return entry.localName || entry.exportName || entry.inlineName || entry.id;
+}
+
+function createUse(router, op, role, ref) {
+  const use = {
+    role,
+    router: router.name,
+    opKind: op.kind,
+    order: op.order,
+    statementOrder: op.statementOrder,
+    loc: ref?.loc || op.loc
+  };
+  if (op.route || op.kind === 'get' || op.kind === 'post') {
+    use.method = op.method || op.kind.toUpperCase();
+    use.path = op.path;
+  }
+  if (op.kind === 'use' && op.path) use.path = op.path;
+  if (op.kind === 'lifecycle') use.event = op.event;
+  if (role === 'event') {
+    use.event = op.type;
+    use.schemaId = op.declaration && op.declaration.schemaId;
+  }
+  return use;
+}
+
+function expectedSignatureForRole(role, registry = DEFAULT_HANDLER_ROLE_REGISTRY) {
+  const definition = registry.get(role);
+  return definition ? { params: definition.params, display: definition.display } : undefined;
+}
+
+function validateEntryForRole(entry, role, use, diagnostics, options = {}) {
+  entry._validatedRoleKeys ||= new Set();
+  const key = `${entry.id}:${role}`;
+  if (entry._validatedRoleKeys.has(key)) return;
+  entry._validatedRoleKeys.add(key);
+
+  const expected = typeof options.expectedSignatureForRole === 'function'
+    ? options.expectedSignatureForRole(role, entry, use)
+    : expectedSignatureForRole(role);
+  const signature = entry.signature || {};
+  const loc = entry.loc || use?.loc || { file: entry.file || '<unknown>' };
+
+  if (!expected) return;
+
+  // Sprint 1 Wave 2: managed Router handlers are async-shaped authoring functions.
+  // Promise runtime semantics remain rejected by the shared handler-surface normalizer.
+
+  if ((signature.nonIdentifierParams || []).length > 0) {
+    diagnostics.push({
+      pass: 'handler-table',
+      code: 'PULSEWASM_UNSUPPORTED_HANDLER_PARAMETER',
+      severity: 'error',
+      message: `Handler "${handlerDisplayName(entry)}" uses destructured or non-identifier parameters.`,
+      hint: `Use the explicit ${expected.display} role signature.`,
+      loc
+    });
+  }
+
+  const expectedParams = Array.isArray(expected.params) ? expected.params : [expected.params];
+  if (!expectedParams.includes(signature.paramCount)) {
+    diagnostics.push({
+      pass: 'handler-table',
+      code: 'PULSEWASM_ROLE_SIGNATURE_MISMATCH',
+      severity: 'error',
+      message: `Handler "${handlerDisplayName(entry)}" is used as ${role} but has ${signature.paramCount ?? 0} parameter(s).`,
+      hint: `Expected ${expected.display}.`,
+      loc
+    });
+  }
+}
+
+function cleanEntry(entry) {
+  const out = { ...entry };
+  delete out._validatedRoleKeys;
+  out.roles = uniqueSorted(out.roles || []);
+  return out;
+}
+
+function buildHandlerTable(ir, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const diagnostics = [];
+  const declarationsByName = new Map();
+  const entriesBySymbolName = new Map();
+  const entriesById = new Map();
+  const handlers = [];
+  let nextOrder = 0;
+
+  for (const decl of ir.handlerIR || []) {
+    declarationsByName.set(decl.symbolId || decl.name, decl);
+  }
+
+  function addEntry(entry) {
+    const existing = entriesById.get(entry.id);
+    if (existing) return existing;
+    entry.order = nextOrder++;
+    entry.roles ||= [];
+    entry.uses ||= [];
+    entriesById.set(entry.id, entry);
+    handlers.push(entry);
+    if (entry.symbolId) entriesBySymbolName.set(entry.symbolId, entry);
+    else if (entry.localName) entriesBySymbolName.set(entry.localName, entry);
+    return entry;
+  }
+
+  function entryFromDeclaration(decl) {
+    const localName = decl.localName || decl.name;
+    const symbolId = decl.symbolId && decl.symbolId !== localName ? decl.symbolId : undefined;
+    const lookupName = symbolId || localName;
+    const existing = entriesBySymbolName.get(lookupName);
+    if (existing) return existing;
+    const stableInput = createHandlerStableInput({
+      file: decl.file,
+      kind: decl.kind,
+      localName,
+      exportName: decl.exportName,
+      inline: false,
+      sourceTextHash: decl.sourceTextHash
+    });
+    const id = createHandlerStableId({
+      file: decl.file,
+      kind: decl.kind,
+      localName,
+      exportName: decl.exportName,
+      inline: false,
+      sourceTextHash: decl.sourceTextHash
+    });
+    return addEntry({
+      id,
+      stableInput,
+      kind: decl.kind,
+      ...(symbolId ? { symbolId } : {}),
+      localName,
+      exportName: decl.exportName,
+      file: decl.file,
+      loc: decl.loc,
+      sourceTextHash: decl.sourceTextHash,
+      declaration: {
+        topLevel: true,
+        exported: Boolean(decl.exportName)
+      },
+      signature: decl.signature
+    });
+  }
+
+  function entryFromInline(ref, role, router, op) {
+    const inlineName = `<inline:${role}:${router.name}:${op.order}>`;
+    const file = stableFileName(ref.loc?.file || ir.source, cwd);
+    const stableLoc = ref.loc
+      ? {
+          file,
+          start: ref.loc.start,
+          end: ref.loc.end
+        }
+      : undefined;
+    const stableInput = createHandlerStableInput({
+      file,
+      kind: ref.inlineKind || 'inline-function',
+      localName: null,
+      exportName: null,
+      inline: true,
+      loc: stableLoc,
+      sourceTextHash: ref.sourceTextHash
+    });
+    const id = createHandlerStableId({
+      file,
+      kind: ref.inlineKind || 'inline-function',
+      localName: null,
+      exportName: null,
+      inline: true,
+      loc: stableLoc,
+      sourceTextHash: ref.sourceTextHash
+    });
+    return addEntry({
+      id,
+      stableInput,
+      kind: ref.inlineKind || 'inline-function',
+      inlineName,
+      file,
+      loc: ref.loc,
+      sourceTextHash: ref.sourceTextHash,
+      declaration: {
+        topLevel: false,
+        exported: false
+      },
+      signature: ref.signature
+    });
+  }
+
+  function resolveRef(ref, role, router, op) {
+    if (!ref) return ref;
+    if (ref.kind === 'static') return clone(ref);
+
+    let entry;
+    if (ref.kind === 'identifier' || ref.kind === 'ref') {
+      const decl = declarationsByName.get(ref.value);
+      if (!decl) {
+        diagnostics.push({
+          pass: 'handler-table',
+          code: 'PULSEWASM_UNRESOLVED_HANDLER_REFERENCE',
+          severity: 'error',
+          message: `Unable to resolve ${role} handler "${ref.value}" as a top-level handler declaration.`,
+          hint: 'Use a top-level function declaration, const arrow function, or const function expression in the same entry file.',
+          loc: ref.loc || op.loc
+        });
+        return { kind: 'unresolved', name: ref.value, role, loc: ref.loc || op.loc };
+      }
+      entry = entryFromDeclaration(decl);
+    } else if (ref.kind === 'inline') {
+      entry = entryFromInline(ref, role, router, op);
+    } else {
+      diagnostics.push({
+        pass: 'handler-table',
+        code: 'PULSEWASM_UNSUPPORTED_HANDLER_REFERENCE',
+        severity: 'error',
+        message: `Unsupported ${role} handler reference kind "${ref.kind}".`,
+        hint: 'Use a direct handler identifier or an inline function expression.',
+        loc: ref.loc || op.loc
+      });
+      return { kind: 'unsupported', name: ref.value, role, loc: ref.loc || op.loc };
+    }
+
+    const use = createUse(router, op, role, ref);
+    entry.roles.push(role);
+    entry.uses.push(use);
+    validateEntryForRole(entry, role, use, diagnostics, options);
+
+    return {
+      kind: 'handler',
+      id: entry.id,
+      name: entry.localName || entry.inlineName,
+      role,
+      loc: ref.loc || op.loc
+    };
+  }
+
+  const resolvedRouterIR = (ir.routerIR || []).map((router) => ({
+    ...router,
+    ops: (router.ops || []).map((op) => {
+      const next = clone(op);
+      const role = roleForOperation(next);
+      if (!role) return next;
+      if (next.kind === 'channel') {
+        if (next.value && next.value.kind !== 'static') {
+          next.value = resolveRef(next.value, role, router, next);
+        }
+        return next;
+      }
+      if (next.handler) next.handler = resolveRef(next.handler, role, router, next);
+      return next;
+    })
+  }));
+
+  const resolvedEventIR = (ir.eventIR || []).map((op) => {
+    const next = clone(op);
+    if (next.handler) next.handler = resolveRef(next.handler, 'event', { name: next.router }, next);
+    return next;
+  });
+
+  const artifactHandlers = handlers.map(cleanEntry);
+  const eventActive = resolvedEventIR.length > 0;
+  const artifact = normalizeArtifact({
+    version: HANDLER_TABLE_VERSION,
+    generatedBy: PACKAGE_VERSION,
+    source: ir.source,
+    idPolicy: HANDLER_ID_POLICY,
+    roleSignatures: eventActive ? { ...ROLE_SIGNATURES, event: EVENT_ROLE_SIGNATURE } : ROLE_SIGNATURES,
+    handlers: artifactHandlers,
+    summary: {
+      handlers: artifactHandlers.length,
+      declarationHandlers: artifactHandlers.filter((entry) => entry.declaration?.topLevel).length,
+      inlineHandlers: artifactHandlers.filter((entry) => !entry.declaration?.topLevel).length,
+      roles: uniqueSorted(artifactHandlers.flatMap((entry) => entry.roles || [])),
+      ...(eventActive ? { eventHandlers: artifactHandlers.filter((entry) => entry.roles.includes('event')).length } : {}),
+      diagnostics: diagnostics.length
+    }
+  }, cwd);
+
+  return {
+    handlerTable: artifact,
+    diagnostics,
+    resolvedIR: {
+      ...ir,
+      routerIR: resolvedRouterIR,
+      ...(eventActive ? { eventIR: resolvedEventIR } : {}),
+      handlerIR: artifact.handlers
+    }
+  };
+}
+
+module.exports = {
+  HANDLER_ID_POLICY,
+  HANDLER_TABLE_VERSION,
+  ROLE_SIGNATURES,
+  EVENT_ROLE_SIGNATURE,
+  buildHandlerTable,
+  expectedSignatureForRole,
+  roleForOperation
+};

package/src/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = {
+  astJson: require('./ast-json.js'),
+  buildManifest: require('./build-manifest.js'),
+  cli: require('./cli.js'),
+  configResolver: require('./config-resolver.js'),
+  projectConfigCompiler: require('./project-config-compiler.js'),
+  diagnostics: require('./diagnostics.js'),
+  canonicalApiCompiler: require('./canonical-api-compiler.js'),
+  canonicalNativePlan: require('./canonical-native-plan.js'),
+  canonicalNativeCompiler: require('./canonical-native-compiler.js'),
+  dispatchTable: require('./dispatch-table.js'),
+  executionPlan: require('./execution-plan.js'),
+  extractor: require('./extractor.js'),
+  handlerEval: require('./handler-eval.js'),
+  handlerTable: require('./handler-table.js'),
+  pathTable: require('./path-table.js')
+};

package/src/javascript-application-plan.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const path = require('node:path');
+const {
+  buildReachableProjectGraph,
+  ReachableProjectGraphError
+} = require('./project/reachable-graph-builder.js');
+const {
+  JAVASCRIPT_APPLICATION_PLAN_VERSION,
+  normalizeJavascriptApplicationPlan
+} = require('@pulse-compute/wasm-contracts/project/javascript-application');
+
+const JAVASCRIPT_APPLICATION_PLANNER_VERSION = 'pulse.javascript-application-planner.v1';
+const CORE_APPLICATION_PACKAGES = new Set(['@pulse-compute/runtime', '@pulse-compute/pulse']);
+
+class JavascriptApplicationPlanError extends Error {
+  constructor(code, message, detail = {}, diagnostics = []) {
+    super(message);
+    this.name = 'JavascriptApplicationPlanError';
+    this.code = code;
+    this.detail = Object.freeze({ ...detail });
+    this.diagnostics = Object.freeze([...diagnostics]);
+  }
+}
+
+function moduleSources(graph, moduleId) {
+  return Object.freeze(graph.edges
+    .filter((edge) => edge.runtime && edge.to === moduleId && edge.source)
+    .map((edge) => edge.source)
+    .sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column));
+}
+
+function packageStatus(module, graphBuild) {
+  if (CORE_APPLICATION_PACKAGES.has(module.packageName)) {
+    return Object.freeze({ status: 'supplied-core', runtimeEntry: module.packageName, reasonCode: null });
+  }
+  const product = graphBuild.packageProduct && graphBuild.packageProduct.contracts
+    .find((entry) => entry.packageName === module.packageName);
+  if (product) {
+    const target = product.javascriptTarget;
+    if (target && target.status === 'supported') {
+      return Object.freeze({ status: 'package-runtime', runtimeEntry: target.entry, reasonCode: null });
+    }
+    return Object.freeze({
+      status: 'unavailable',
+      runtimeEntry: null,
+      reasonCode: target && target.reasonCode || 'PULSE_JAVASCRIPT_PACKAGE_REALIZATION_UNAVAILABLE'
+    });
+  }
+  if (module.packageContract) {
+    return Object.freeze({
+      status: 'unavailable',
+      runtimeEntry: null,
+      reasonCode: 'PULSE_JAVASCRIPT_PACKAGE_REALIZATION_UNAVAILABLE'
+    });
+  }
+  return Object.freeze({ status: 'node-require', runtimeEntry: module.packageName, reasonCode: null });
+}
+
+function createPackageEntries(graphBuild) {
+  return graphBuild.graph.modules
+    .filter((module) => module.runtime && module.kind === 'package')
+    .map((module) => {
+      const status = packageStatus(module, graphBuild);
+      return Object.freeze({
+        moduleId: module.id,
+        packageName: module.packageName,
+        packageSubpath: module.packageSubpath,
+        contractId: module.packageContract,
+        status: status.status,
+        runtimeEntry: status.runtimeEntry,
+        reasonCode: status.reasonCode,
+        sources: moduleSources(graphBuild.graph, module.id)
+      });
+    });
+}
+
+function createBlockers(graphBuild, packages) {
+  const blockers = [];
+  if (graphBuild.entrySafety && graphBuild.entrySafety.importSafe === false) {
+    const first = graphBuild.nativeEligibility && graphBuild.nativeEligibility.blockers
+      .find((entry) => entry.kind === 'application-entry-lifecycle-side-effect');
+    blockers.push(Object.freeze({
+      code: 'PULSE_APPLICATION_ENTRY_LIFECYCLE_SIDE_EFFECT',
+      kind: 'application-entry-lifecycle-side-effect',
+      message: 'The configured Pulse application entry starts a known provider lifecycle during module evaluation.',
+      moduleId: first && first.moduleId || graphBuild.graph.entry,
+      source: first && first.source || { file: graphBuild.entryKey, line: 1, column: 1 }
+    }));
+  }
+  for (const entry of packages.filter((item) => item.status === 'unavailable')) {
+    const source = entry.sources[0] || { file: graphBuild.entryKey, line: 1, column: 1 };
+    blockers.push(Object.freeze({
+      code: entry.reasonCode || 'PULSE_JAVASCRIPT_PACKAGE_REALIZATION_UNAVAILABLE',
+      kind: 'javascript-package-realization-unavailable',
+      message: `Package ${entry.packageName}${entry.packageSubpath && entry.packageSubpath !== '.' ? entry.packageSubpath.slice(1) : ''} has no JavaScript realization for the selected target.`,
+      moduleId: entry.moduleId,
+      packageName: entry.packageName,
+      packageSubpath: entry.packageSubpath,
+      contractId: entry.contractId,
+      source
+    }));
+  }
+  return blockers;
+}
+
+function buildJavascriptApplicationPlan(entryFile, options = {}) {
+  const absoluteEntry = path.resolve(entryFile);
+  let graphBuild;
+  try {
+    graphBuild = buildReachableProjectGraph(absoluteEntry, {
+      rootDir: options.rootDir,
+      workspaceRoot: options.workspaceRoot,
+      configFile: options.configFile,
+      projectFragments: options.projectFragments,
+      tsconfig: options.tsconfig
+    });
+  } catch (error) {
+    if (error instanceof ReachableProjectGraphError || error && error.name === 'ReachableProjectGraphError') {
+      throw new JavascriptApplicationPlanError(
+        error.code || 'PULSE_JAVASCRIPT_APPLICATION_GRAPH_FAILED',
+        error.message,
+        error.detail,
+        error.diagnostics
+      );
+    }
+    throw error;
+  }
+  const entryModule = graphBuild.graph.modules.find((module) => module.id === graphBuild.graph.entry);
+  if (!entryModule || entryModule.kind !== 'project' || !entryModule.path) {
+    throw new JavascriptApplicationPlanError(
+      'PULSE_JAVASCRIPT_APPLICATION_ENTRY_INVALID',
+      'JavaScript application plan entry must resolve to a project module.',
+      { entryFile: absoluteEntry, graphEntry: graphBuild.graph.entry }
+    );
+  }
+  const packages = createPackageEntries(graphBuild);
+  const blockers = createBlockers(graphBuild, packages);
+  const requestedEnvelope = options.capabilityEnvelope || {};
+  const capabilityEnvelope = Object.freeze({
+    version: requestedEnvelope.version || 'pulse.javascript-capability-envelope.v1',
+    provider: requestedEnvelope.provider || options.provider || 'node',
+    status: requestedEnvelope.status || 'provider-adapters-deferred',
+    core: requestedEnvelope.core || Object.freeze({ request: true, response: true, state: true }),
+    effects: requestedEnvelope.effects || Object.freeze({ fetch: false, config: false, secret: false, kv: false }),
+    packages: Object.freeze(packages.map((entry) => Object.freeze({
+      contractId: entry.contractId,
+      packageName: entry.packageName,
+      status: entry.status
+    })))
+  });
+  const plan = normalizeJavascriptApplicationPlan({
+    provider: options.provider || 'node',
+    targetId: options.targetId || 'node-javascript',
+    entryPath: entryModule.path,
+    graphVersion: graphBuild.graph.version,
+    graphHash: graphBuild.graph.graphHash,
+    resolverHash: graphBuild.graph.resolver.resolverHash,
+    entryModuleId: graphBuild.graph.entry,
+    modules: graphBuild.graph.modules,
+    edges: graphBuild.graph.edges,
+    packages,
+    blockers,
+    packageProduct: graphBuild.packageProduct,
+    nativeEligibility: graphBuild.nativeEligibility,
+    entrySafety: graphBuild.entrySafety,
+    capabilityEnvelope,
+    providerLifecycleDeferred: options.providerLifecycleDeferred !== false
+  });
+  return Object.freeze({
+    ...plan,
+    plannerVersion: JAVASCRIPT_APPLICATION_PLANNER_VERSION
+  });
+}
+
+module.exports = Object.freeze({
+  JAVASCRIPT_APPLICATION_PLANNER_VERSION,
+  JAVASCRIPT_APPLICATION_PLAN_VERSION,
+  JavascriptApplicationPlanError,
+  buildJavascriptApplicationPlan
+});

package/src/kv-provider.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@pulse-compute/wasm-host-runtime/runtime/kv-provider');

package/src/path-table.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const { PACKAGE_VERSION, normalizeArtifact } = require('./diagnostics.js');
+const { PATH_POLICY, compileRoutePath, publicPathPattern } = require('./path.js');
+const { PATH_TABLE_VERSION } = loadContractsPathTable();
+
+function loadContractsPathTable() {
+  try {
+    return require('@pulse-compute/wasm-contracts/path-table');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../contracts/src/path-table.js');
+    }
+    throw error;
+  }
+}
+
+function buildPathTable(routePlan, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const routes = (routePlan.routes || []).map((route) => {
+    const compiled = route.pathPattern || publicPathPattern(compileRoutePath(route.path, { allowWildcard: true }));
+    return {
+      stableId: route.stableId,
+      runtimeId: route.runtimeId ?? route.id,
+      method: route.method,
+      path: route.path,
+      params: route.params || [],
+      pattern: compiled,
+      scopedMiddleware: route.scopedMiddleware || []
+    };
+  });
+
+  const scopedMiddlewareMatches = routes.reduce((sum, route) => sum + (route.scopedMiddleware || []).length, 0);
+  const wildcardRoutes = routes.filter((route) => route.pattern && route.pattern.wildcard).length;
+  const paramNames = new Set();
+  for (const route of routes) {
+    for (const param of route.params || []) paramNames.add(param);
+  }
+
+  return normalizeArtifact({
+    version: PATH_TABLE_VERSION,
+    generatedBy: options.generatedBy || routePlan.generatedBy || PACKAGE_VERSION,
+    source: routePlan.source,
+    entryRouter: routePlan.entryRouter,
+    policy: PATH_POLICY,
+    routes,
+    summary: {
+      routes: routes.length,
+      wildcardRoutes,
+      scopedMiddlewareMatches,
+      uniqueParams: paramNames.size,
+      paramNames: Array.from(paramNames).sort()
+    }
+  }, cwd);
+}
+
+module.exports = {
+  PATH_TABLE_VERSION,
+  buildPathTable
+};

package/src/path.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function loadContractsPath() {
+  try {
+    return require('@pulse-compute/wasm-contracts/path');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../contracts/src/path.js');
+    }
+    throw error;
+  }
+}
+
+module.exports = loadContractsPath();

package/src/patterns/config-define.js

@@ -0,0 +1,30 @@
+'use strict';
+
+function isTopLevelDefineConfigCall(ts, sourceFile, call) {
+  const parent = call.parent;
+  if (!parent) return false;
+  if (ts.isExportAssignment(parent)) return true;
+  if (ts.isVariableDeclaration(parent)) {
+    const declList = parent.parent;
+    const varStmt = declList && declList.parent;
+    return Boolean(varStmt && ts.isVariableStatement(varStmt) && varStmt.parent === sourceFile);
+  }
+  return false;
+}
+
+function collectDefineConfigCalls(ts, sourceFile) {
+  const calls = [];
+  function walk(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'defineConfig') {
+      calls.push(node);
+    }
+    ts.forEachChild(node, walk);
+  }
+  walk(sourceFile);
+  return calls;
+}
+
+module.exports = {
+  collectDefineConfigCalls,
+  isTopLevelDefineConfigCall
+};

package/src/patterns/dependency-call.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function classifyCallExpression(ts, call, scope) {
+  const expr = call.expression;
+  if (ts.isIdentifier(expr)) {
+    if (expr.text === 'next') return { kind: 'continuation', name: 'next', resolved: true };
+    if (scope && scope.localFunctions && scope.localFunctions.has(expr.text)) {
+      return { kind: 'local-function', name: expr.text, resolved: true };
+    }
+    return { kind: 'identifier', name: expr.text, resolved: false };
+  }
+  if (ts.isPropertyAccessExpression(expr)) {
+    return { kind: 'member', name: expr.name.text, resolved: false };
+  }
+  return { kind: 'dynamic', name: call.getText ? call.getText() : '<dynamic>', resolved: false };
+}
+
+module.exports = { classifyCallExpression };

package/src/patterns/env-lookup.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function isEnvCall(ts, expr, envParamName) {
+  if (ts.isIdentifier(expr) && expr.text === envParamName) {
+    return { method: 'string' };
+  }
+  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === envParamName) {
+    return { method: expr.name.text, nameNode: expr.name };
+  }
+  return null;
+}
+
+module.exports = { isEnvCall };