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

package/src/codegen/assemblyscript-compile.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@pulse-compute/wasm-build-support/assemblyscript-compile');

package/src/codegen/assemblyscript-core.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@pulse-compute/wasm-runtime-core-as/compiler/assemblyscript-core');

package/src/codegen/assemblyscript-shape.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@pulse-compute/wasm-runtime-core-as/compiler/assemblyscript-shape');

package/src/codegen/assemblyscript-wasm-smoke.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@pulse-compute/wasm-runtime-core-as/compiler/assemblyscript-wasm-smoke');

package/src/codegen/backend-capabilities.js

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

package/src/codegen/channel-broadcaster.js

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

package/src/codegen/compiled-handlers.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('@pulse-compute/wasm-runtime-core-as/compiler/compiled-handlers');

package/src/codegen/compiled-wasm-runtime.js

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

package/src/codegen/config-references.js

@@ -0,0 +1,248 @@
+'use strict';
+
+const { PACKAGE_VERSION, normalizeArtifact, normalizeDiagnostic } = require('../diagnostics.js');
+const {
+  CONFIG_REFERENCES_VERSION,
+  RUNTIME_CONFIG_REFERENCES_VERSION,
+  PLATFORM_STORE_MAP_VERSION,
+  CONFIG_AUTHORING_SHAPE_VERSION,
+  CONFIG_REFERENCES_PHASE: PHASE,
+  collectSymbolicRefs,
+  groupSymbolicRefs,
+  isSymbolicRef,
+  normalizeSymbolicRef,
+  configAuthoringShape
+} = loadContractsSymbolicRefs();
+
+function loadContractsSymbolicRefs() {
+  try {
+    return require('@pulse-compute/wasm-contracts/config/symbolic-refs');
+  } catch (error) {
+    if (error && error.code === 'MODULE_NOT_FOUND' && String(error.message).includes('@pulse-compute/wasm-contracts')) {
+      return require('../../../contracts/src/config/symbolic-refs.js');
+    }
+    throw error;
+  }
+}
+
+function plainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function configArtifact(options = {}) {
+  return options.resolvedConfig?.artifact || options.resolvedConfig || {};
+}
+
+function makeDiagnostic(code, message, hint, details) {
+  return normalizeDiagnostic({
+    severity: 'error',
+    phase: 'config-references',
+    code,
+    message,
+    hint,
+    details,
+    loc: { file: '<config>' }
+  });
+}
+
+function validateRefs(refs) {
+  const diagnostics = [];
+  const keys = new Set();
+  for (const ref of refs) {
+    const path = ref.path.join('.');
+    if (ref.kind === 'mixed') {
+      diagnostics.push(makeDiagnostic(
+        'PULSEWASM_CONFIG_REF_MIXED_KIND',
+        `Config reference at ${path} declares both $config and $secret.`,
+        'Use exactly one symbolic reference marker: { $config: "NAME" } or { $secret: "NAME" }.',
+        { path, raw: ref.raw }
+      ));
+      continue;
+    }
+    if (typeof ref.key !== 'string' || ref.key.trim() === '') {
+      diagnostics.push(makeDiagnostic(
+        'PULSEWASM_CONFIG_REF_KEY_INVALID',
+        `Config reference at ${path} must use a non-empty string key.`,
+        'Use a literal key such as { $config: "USERS_API_BASE_URL" } or { $secret: "USERS_API_TOKEN" }.',
+        { path, raw: ref.raw }
+      ));
+    }
+    const allowedKeys = new Set([ref.kind === 'config' ? '$config' : '$secret']);
+    for (const key of Object.keys(ref.raw || {})) {
+      if (!allowedKeys.has(key)) {
+        diagnostics.push(makeDiagnostic(
+          'PULSEWASM_CONFIG_REF_EXTRA_KEY',
+          `Config reference at ${path} contains unsupported property ${key}.`,
+          'Symbolic refs are intentionally tiny. Use only { $config: "NAME" } or { $secret: "NAME" }.',
+          { path, property: key }
+        ));
+      }
+    }
+    keys.add(`${ref.kind}:${ref.key}`);
+  }
+  return diagnostics;
+}
+
+function buildConfigReferenceContract(generatedBy) {
+  return {
+    version: CONFIG_REFERENCES_VERSION,
+    generatedBy,
+    phase: PHASE,
+    status: 'locked',
+    canonicalRefs: {
+      config: { authoring: '{ $config: "KEY" }', secret: false, compiledIntoBinary: false },
+      secret: { authoring: '{ $secret: "KEY" }', secret: true, compiledIntoBinary: false }
+    },
+    authoringPolicy: {
+      envHelperRequired: false,
+      envHelperCanonical: false,
+      profileSelection: 'external PULSE_PROFILE / CLI profile, not defineConfig env() helper',
+      verboseMappings: 'generated-artifact-only',
+      rootTopologyOnly: ['entry', 'rootRouter', 'profiles'],
+      runtimeSettingsLiveUnder: 'profiles.<name>.runtime'
+    },
+    nonGoals: [
+      'no platform store lookup implementation',
+      'no Fastly config/secret hostcalls',
+      'no automatic env fallback',
+      'no secret values compiled into Wasm'
+    ]
+  };
+}
+
+function buildMarkdown(artifact, runtimeRefs, platformMap, authoringShape) {
+  const lines = [];
+  lines.push('# PulseWasm Static Config References Contract v1');
+  lines.push('');
+  lines.push(`Generated by: \`${artifact.generatedBy}\``);
+  lines.push(`Phase: \`${artifact.phase}\``);
+  lines.push('');
+  lines.push('## Locked position');
+  lines.push('');
+  lines.push('- Author configs use symbolic refs: `{ $config: "KEY" }` and `{ $secret: "KEY" }`.');
+  lines.push('- `env()` is not required for canonical config authoring.');
+  lines.push('- `PULSE_PROFILE` / CLI `--profile` selects the profile externally.');
+  lines.push('- Verbose provider mappings are generated artifacts only.');
+  lines.push('- Secrets are symbolic and never compiled into the Wasm binary.');
+  lines.push('');
+  lines.push('## Current refs');
+  lines.push('');
+  if (runtimeRefs.refs.length === 0) {
+    lines.push('No symbolic config refs were found in the selected profile runtime.');
+  } else {
+    for (const ref of runtimeRefs.refs) {
+      lines.push(`- \`${ref.kind}\` \`${ref.key}\` at \`${ref.path.join('.')}\` → provider \`${ref.provider}\`${ref.store ? ` store \`${ref.store}\`` : ''}`);
+    }
+  }
+  lines.push('');
+  lines.push('## Fastly store mapping');
+  lines.push('');
+  lines.push(`- config store: ${platformMap.fastly.configStore.name ? `\`${platformMap.fastly.configStore.name}\`` : '`<unmapped>`'}`);
+  lines.push(`- secret store: ${platformMap.fastly.secretStore.name ? `\`${platformMap.fastly.secretStore.name}\`` : '`<unmapped>`'}`);
+  lines.push('');
+  lines.push('## Authoring shape');
+  lines.push('');
+  lines.push(`Root allowed keys: ${authoringShape.root.allowedKeys.map((key) => `\`${key}\``).join(', ')}`);
+  lines.push(`Profile runtime keys: ${authoringShape.profile.runtimeKeys.map((key) => `\`${key}\``).join(', ')}`);
+  return lines.join('\n');
+}
+
+function buildConfigReferences(options = {}) {
+  const generatedBy = options.generatedBy || PACKAGE_VERSION;
+  const config = configArtifact(options);
+  const runtime = plainObject(config.runtime);
+  const rawRefs = collectSymbolicRefs(runtime);
+  const refs = rawRefs.map((ref) => normalizeSymbolicRef(ref, runtime));
+  const diagnostics = validateRefs(rawRefs);
+  const platformMap = groupSymbolicRefs(rawRefs, runtime);
+
+  const missingFastlyConfigStore = refs.some((ref) => ref.kind === 'config' && ref.provider === 'unmapped.configStore');
+  const missingFastlySecretStore = refs.some((ref) => ref.kind === 'secret' && ref.provider === 'unmapped.secretStore');
+  if (missingFastlyConfigStore) {
+    diagnostics.push(makeDiagnostic(
+      'PULSEWASM_CONFIG_REF_FASTLY_CONFIG_STORE_UNMAPPED',
+      'One or more $config refs are present but runtime.platform.fastly.configStore is not configured.',
+      'Set profiles.<name>.runtime.platform.fastly.configStore to the Fastly config store name.',
+      { refs: refs.filter((ref) => ref.kind === 'config') }
+    ));
+  }
+  if (missingFastlySecretStore) {
+    diagnostics.push(makeDiagnostic(
+      'PULSEWASM_CONFIG_REF_FASTLY_SECRET_STORE_UNMAPPED',
+      'One or more $secret refs are present but runtime.platform.fastly.secretStore is not configured.',
+      'Set profiles.<name>.runtime.platform.fastly.secretStore to the Fastly secret store name.',
+      { refs: refs.filter((ref) => ref.kind === 'secret') }
+    ));
+  }
+
+  const runtimeRefs = {
+    version: RUNTIME_CONFIG_REFERENCES_VERSION,
+    generatedBy,
+    phase: PHASE,
+    profile: config.profile || null,
+    refs,
+    summary: {
+      refs: refs.length,
+      configRefs: refs.filter((ref) => ref.kind === 'config').length,
+      secretRefs: refs.filter((ref) => ref.kind === 'secret').length,
+      compiledIntoBinary: refs.filter((ref) => ref.compiledIntoBinary).length,
+      diagnostics: diagnostics.length
+    }
+  };
+
+  const platformStoreMap = {
+    version: PLATFORM_STORE_MAP_VERSION,
+    generatedBy,
+    phase: PHASE,
+    profile: config.profile || null,
+    policy: {
+      verboseMappingsAreGeneratedOnly: true,
+      configValuesAreNotSecrets: true,
+      secretValuesNeverCompileIntoBinary: true,
+      fastlyIsProviderNotAuthoringShape: true
+    },
+    stores: platformMap,
+    summary: {
+      fastlyConfigStoreReady: platformMap.fastly.configStore.ready,
+      fastlySecretStoreReady: platformMap.fastly.secretStore.ready,
+      localProviderReserved: true
+    }
+  };
+
+  const authoringShape = configAuthoringShape(generatedBy, PHASE);
+
+  const artifact = buildConfigReferenceContract(generatedBy);
+  artifact.profile = config.profile || null;
+  artifact.summary = {
+    refs: refs.length,
+    configRefs: runtimeRefs.summary.configRefs,
+    secretRefs: runtimeRefs.summary.secretRefs,
+    fastlyConfigStoreReady: platformStoreMap.summary.fastlyConfigStoreReady,
+    fastlySecretStoreReady: platformStoreMap.summary.fastlySecretStoreReady,
+    diagnostics: diagnostics.length
+  };
+
+  const files = [{
+    file: 'generated/host/config-references.md',
+    text: buildMarkdown(artifact, runtimeRefs, platformMap, authoringShape)
+  }];
+
+  return {
+    artifact: normalizeArtifact(artifact, options.cwd),
+    runtimeReferences: normalizeArtifact(runtimeRefs, options.cwd),
+    platformStoreMap: normalizeArtifact(platformStoreMap, options.cwd),
+    authoringShape: normalizeArtifact(authoringShape, options.cwd),
+    diagnostics,
+    files
+  };
+}
+
+module.exports = {
+  CONFIG_REFERENCES_VERSION,
+  RUNTIME_CONFIG_REFERENCES_VERSION,
+  PLATFORM_STORE_MAP_VERSION,
+  CONFIG_AUTHORING_SHAPE_VERSION,
+  buildConfigReferences,
+  collectSymbolicRefs,
+  isSymbolicRef
+};

package/src/codegen/dispatch-ts.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { PACKAGE_VERSION, normalizeArtifact } = require('../diagnostics.js');
+
+const DISPATCH_TS_VERSION = 'pulsewasm.dispatch-ts.v3';
+
+function sha256(text) {
+  return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+function tsJson(value) {
+  return JSON.stringify(value, null, 2)
+    .replace(/</g, '\\u003c')
+    .replace(/>/g, '\\u003e')
+    .replace(/&/g, '\\u0026');
+}
+
+function header() {
+  return [
+    '/*',
+    ' * Generated by PulseWasm Phase 8A/8B/8C/8E.',
+    ' * Do not edit by hand.',
+    ' *',
+    ' * This file is generated from validated PulseWasm dispatch metadata.',
+    ' * It must not re-read user source or re-infer route semantics.',
+    ' */',
+    ''
+  ].join('\n');
+}
+
+function buildTypesSource() {
+  return `${header()}export type DispatchParamMap = Record<string, string>\n\nexport type DispatchSegment =\n  | { readonly kind: 'literal'; readonly value: string }\n  | { readonly kind: 'param'; readonly name: string }\n  | { readonly kind: 'wildcard' }\n\nexport type DispatchPathPattern = {\n  readonly grammarVersion: string\n  readonly normalized: string\n  readonly scoped: boolean\n  readonly wildcard: boolean\n  readonly segments: readonly DispatchSegment[]\n  readonly params: readonly string[]\n}\n\nexport type HandlerUse = {\n  readonly slot: number | null\n  readonly id?: string\n  readonly handlerId?: string\n  readonly name?: string\n  readonly role?: string\n  readonly kind?: string\n  readonly index?: number\n  readonly order?: number\n  readonly evalStatus?: string\n  readonly unresolved?: boolean\n}\n\nexport type DispatchRoute = {\n  readonly stableId: string\n  readonly runtimeId: number\n  readonly id: number\n  readonly method: string\n  readonly path: string\n  readonly params: readonly string[]\n  readonly pattern: DispatchPathPattern\n  readonly handlers: {\n    readonly middleware: readonly HandlerUse[]\n    readonly route: HandlerUse\n    readonly error: readonly HandlerUse[]\n    readonly lifecycle: {\n      readonly connect: readonly HandlerUse[]\n      readonly disconnect: readonly HandlerUse[]\n    }\n    readonly channel?: HandlerUse | { readonly kind: 'static'; readonly value: string }\n  }\n  readonly execution: {\n    readonly normal: readonly HandlerUse[]\n    readonly error: readonly HandlerUse[]\n    readonly lifecycle: {\n      readonly connect: readonly HandlerUse[]\n      readonly disconnect: readonly HandlerUse[]\n    }\n    readonly channel?: HandlerUse | { readonly kind: 'static'; readonly value: string }\n  }\n}\n\nexport type DispatchMatch = {\n  readonly stableId: string\n  readonly runtimeId: number\n  readonly id: number\n  readonly method: string\n  readonly path: string\n  readonly requestPath: string\n  readonly params: DispatchParamMap\n  readonly rest: string\n  readonly handlers: DispatchRoute['handlers']\n  readonly execution: DispatchRoute['execution']\n  readonly route: DispatchRoute\n}\n`;
+}
+
+function buildRouteTableSource(dispatchTable) {
+  const routes = dispatchTable.routes || [];
+  const methodBuckets = dispatchTable.methodBuckets || {};
+  const handlerSlots = dispatchTable.handlerSlots || [];
+  const summary = dispatchTable.summary || {};
+  const routeCases = routes
+    .map((route, index) => `    case ${Number(route.runtimeId)}: return ROUTES[${index}]`)
+    .join('\n');
+  const routeSwitchBody = routeCases ? `${routeCases}\n    default: return undefined` : '    default: return undefined';
+
+  return `${header()}import type { DispatchRoute } from './types'\n\nexport const DISPATCH_TABLE_VERSION = ${tsJson(dispatchTable.version)} as const\nexport const DISPATCH_GENERATED_BY = ${tsJson(dispatchTable.generatedBy)} as const\n\nexport const METHOD_BUCKETS = ${tsJson(methodBuckets)} as const\n\nexport const HANDLER_SLOTS = ${tsJson(handlerSlots)} as const\n\nexport const ROUTES = ${tsJson(routes)} as const\n\nexport const DISPATCH_SUMMARY = ${tsJson(summary)} as const\n\nexport function getRouteByRuntimeId(runtimeId: number): DispatchRoute | undefined {\n  switch (runtimeId) {\n${routeSwitchBody}\n  }\n}\n`;
+}
+
+function buildDispatchSource() {
+  return `${header()}import { METHOD_BUCKETS, getRouteByRuntimeId } from './route-table'\nimport type { DispatchMatch, DispatchParamMap, DispatchPathPattern, DispatchRoute } from './types'\n\nfunction ensureLeadingSlash(value: string): string {\n  return value.startsWith('/') ? value : '/' + value\n}\n\nfunction trimTrailingSlash(value: string): string {\n  let out = value\n  while (out.length > 1 && out.endsWith('/')) {\n    out = out.slice(0, -1)\n  }\n  return out\n}\n\nexport function normalizeRoutePath(input: string): string {\n  const text = String(input ?? '').trim()\n  return trimTrailingSlash(ensureLeadingSlash(text || '/'))\n}\n\nfunction rawSegments(input: string): string[] {\n  const normalized = normalizeRoutePath(input)\n  if (normalized === '/') return []\n  const body = normalized.slice(1)\n  const segments = body.split('/')\n  if (segments.some((segment) => segment.length === 0)) {\n    throw new Error('Duplicate or empty path segment is unsupported: ' + normalized)\n  }\n  return segments\n}\n\nexport function matchPathPattern(pattern: DispatchPathPattern, requestPath: string): { params: DispatchParamMap; rest: string } | null {\n  const pathSegments = rawSegments(requestPath)\n  const params: DispatchParamMap = {}\n  let pathIndex = 0\n\n  for (const segment of pattern.segments) {\n    if (segment.kind === 'wildcard') {\n      const restSegments = pathSegments.slice(pathIndex)\n      return { params, rest: restSegments.length === 0 ? '/' : '/' + restSegments.join('/') }\n    }\n\n    const value = pathSegments[pathIndex]\n    if (value == null) return null\n\n    if (segment.kind === 'literal') {\n      if (segment.value !== value) return null\n    } else if (segment.kind === 'param') {\n      params[segment.name] = value\n    } else {\n      return null\n    }\n\n    pathIndex += 1\n  }\n\n  if (pathIndex !== pathSegments.length) return null\n  return { params, rest: '/' }\n}\n\nexport function matchRoute(route: DispatchRoute, requestPath: string): DispatchMatch | null {\n  const matched = matchPathPattern(route.pattern, requestPath)\n  if (!matched) return null\n  return {\n    stableId: route.stableId,\n    runtimeId: route.runtimeId,\n    id: route.id,\n    method: route.method,\n    path: route.path,\n    requestPath,\n    params: matched.params,\n    rest: matched.rest,\n    handlers: route.handlers,\n    execution: route.execution,\n    route\n  }\n}\n\nexport function match(method: string, requestPath: string): DispatchMatch | null {\n  const normalizedMethod = String(method || '').toUpperCase()\n  const bucket = (METHOD_BUCKETS as Record<string, readonly number[]>)[normalizedMethod] || []\n\n  for (const runtimeId of bucket) {\n    const route = getRouteByRuntimeId(runtimeId)\n    if (!route) continue\n    const matched = matchRoute(route, requestPath)\n    if (matched) return matched\n  }\n\n  return null\n}\n\nexport const dispatch = match\n`;
+}
+
+function buildIndexSource(options = {}) {
+  const handlerBindingsExport = options.includeHandlerBindings ? "export * from './handler-slots'\n" : '';
+  const executionHarnessExport = options.includeExecutionHarness ? "export * from './execution-plan'\nexport * from './execution-harness'\n" : '';
+  const localHarnessExport = options.includeLocalHarness ? "export * from './local-harness'\n" : '';
+  return `${header()}export * from './types'\nexport * from './route-table'\nexport * from './dispatch'\n${handlerBindingsExport}${executionHarnessExport}${localHarnessExport}`;
+}
+
+function makeFile(file, text) {
+  return {
+    file,
+    bytes: Buffer.byteLength(text, 'utf8'),
+    sha256: sha256(text),
+    text
+  };
+}
+
+function buildTypeScriptDispatch(dispatchTable, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const handlerBindings = options.handlerBindings;
+  const executionHarness = options.executionHarness;
+  const localHarness = options.localHarness;
+  const includeHandlerBindings = Boolean(handlerBindings);
+  const includeExecutionHarness = Boolean(executionHarness);
+  const includeLocalHarness = Boolean(localHarness);
+  const files = [
+    makeFile('generated/types.ts', buildTypesSource()),
+    makeFile('generated/route-table.ts', buildRouteTableSource(dispatchTable)),
+    makeFile('generated/dispatch.ts', buildDispatchSource())
+  ]
+    .concat(includeHandlerBindings ? handlerBindings.files || [] : [])
+    .concat(includeExecutionHarness ? executionHarness.files || [] : [])
+    .concat(includeLocalHarness ? localHarness.files || [] : [])
+    .concat([makeFile('generated/index.ts', buildIndexSource({ includeHandlerBindings, includeExecutionHarness, includeLocalHarness }))]);
+
+  const manifest = normalizeArtifact({
+    version: DISPATCH_TS_VERSION,
+    generatedBy: options.generatedBy || PACKAGE_VERSION,
+    source: dispatchTable?.source,
+    sourceDispatchTableVersion: dispatchTable?.version,
+    routePlanVersion: dispatchTable?.routePlanVersion,
+    handlerTableVersion: dispatchTable?.handlerTableVersion,
+    handlerEvalVersion: dispatchTable?.handlerEvalVersion,
+    pathTableVersion: dispatchTable?.pathTableVersion,
+    handlerBindingsVersion: handlerBindings?.artifact?.version,
+    executionHarnessVersion: executionHarness?.artifact?.version,
+    localHarnessVersion: localHarness?.artifact?.version,
+    output: {
+      language: 'typescript',
+      module: 'esm',
+      directory: 'generated',
+      files: files.map(({ file, bytes, sha256: hash }) => ({ file, bytes, sha256: hash }))
+    },
+    policy: {
+      phase: includeLocalHarness ? '9D' : includeExecutionHarness ? '8E' : includeHandlerBindings ? '8B' : '8A',
+      sourceOfTruth: includeLocalHarness
+        ? 'dispatch-table.json + execution-plan.json + handler-table.json + handler-bindings.json + local-harness.json'
+        : includeExecutionHarness
+        ? 'dispatch-table.json + execution-plan.json + handler-table.json + handler-bindings.json'
+        : includeHandlerBindings
+          ? 'dispatch-table.json + handler-table.json'
+          : 'dispatch-table.json',
+      reReadsSource: false,
+      reInfersRouteSemantics: false,
+      handlerInvocation: includeLocalHarness
+        ? 'local harness emitted; result ABI, Map state, lifecycle entrypoints, and broadcaster adaptor are available'
+        : includeExecutionHarness
+          ? 'execution harness emitted; generated entry scanner and handler slot bindings required'
+        : includeHandlerBindings
+          ? 'handler slot imports emitted; invocation harness reserved for Phase 8C'
+          : 'not emitted in Phase 8A; handler slot bindings are reserved for Phase 8B',
+      handlerBindings: includeHandlerBindings,
+      executionHarness: includeExecutionHarness,
+      localHarness: includeLocalHarness,
+      wasmCodegen: false
+    },
+    summary: {
+      routes: Array.isArray(dispatchTable?.routes) ? dispatchTable.routes.length : 0,
+      methods: Object.keys(dispatchTable?.methodBuckets || {}).sort(),
+      handlerSlots: Array.isArray(dispatchTable?.handlerSlots) ? dispatchTable.handlerSlots.length : 0,
+      handlerBindings: includeHandlerBindings ? handlerBindings?.artifact?.summary?.bindings || 0 : 0,
+      executionHarness: includeExecutionHarness ? executionHarness?.artifact?.summary : undefined,
+      localHarness: includeLocalHarness ? localHarness?.artifact?.summary : undefined,
+      files: files.length
+    }
+  }, cwd);
+
+  return { version: DISPATCH_TS_VERSION, manifest, files, diagnostics: [] };
+}
+
+module.exports = {
+  DISPATCH_TS_VERSION,
+  buildTypeScriptDispatch
+};