@auraindustry/aurajs 0.0.1

package/src/perf-benchmark.mjs

@@ -0,0 +1,549 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+
+import { runHeadlessTest } from './headless-test.mjs';
+import { resolveGateHostBinary } from './host-binary.mjs';
+
+export const PERF_REPORT_SCHEMA = 'aurajs.perf-benchmark.v2';
+export const DEFAULT_PERF_ARTIFACT_ROOT = '.aura/perf';
+export const DEFAULT_PERF_WORKSPACE_ROOT = `${DEFAULT_PERF_ARTIFACT_ROOT}/workspace`;
+export const DEFAULT_PERF_REPORT_PATH = `${DEFAULT_PERF_ARTIFACT_ROOT}/report.json`;
+export const DEFAULT_PERF_EVALUATION_PATH = `${DEFAULT_PERF_ARTIFACT_ROOT}/threshold-evaluation.json`;
+export const DEFAULT_STUTTER_THRESHOLD_MS = 25;
+
+export const DEFAULT_PERF_SCENES = [
+  {
+    id: 'draw2d_primitives',
+    frames: 300,
+    source: `
+      let image = null;
+
+      aura.setup = function () {
+        image = aura.assets.image('player.png');
+      };
+
+      aura.draw = function () {
+        aura.draw2d.clear(6, 9, 16);
+
+        for (let i = 0; i < 120; i += 1) {
+          const x = (i * 7) % aura.window.width;
+          const y = (i * 11) % aura.window.height;
+          aura.draw2d.rect(x, y, 24, 16, aura.colors.white);
+          aura.draw2d.circle(x + 10, y + 8, 6, aura.colors.red);
+          aura.draw2d.line(0, 0, x, y, aura.colors.white, 1);
+          aura.draw2d.image(image, x, y, { width: 16, height: 16 });
+        }
+      };
+    `,
+  },
+  {
+    id: 'sprite_transform_swarm',
+    frames: 360,
+    source: `
+      let image = null;
+      const swarm = [];
+      let elapsed = 0;
+
+      aura.setup = function () {
+        image = aura.assets.image('player.png');
+
+        for (let i = 0; i < 240; i += 1) {
+          swarm.push({
+            lane: i % 18,
+            phase: i * 0.13,
+            radius: 36 + (i % 12) * 14,
+            baseScale: 0.5 + ((i % 5) * 0.2),
+            speed: 0.75 + ((i % 7) * 0.11),
+          });
+        }
+      };
+
+      aura.update = function (dt) {
+        elapsed += dt;
+      };
+
+      aura.draw = function () {
+        aura.draw2d.clear(5, 7, 14);
+
+        const centerX = aura.window.width * 0.5;
+        const centerY = aura.window.height * 0.5;
+
+        for (let i = 0; i < swarm.length; i += 1) {
+          const unit = swarm[i];
+          const theta = (elapsed * unit.speed * 3.5) + unit.phase;
+          const wobble = Math.sin(theta * 1.9) * 10;
+          const x = centerX + Math.cos(theta) * (unit.radius + wobble);
+          const y = ((unit.lane * 38) + (Math.sin(theta * 1.3) * 14) + centerY * 0.2) % aura.window.height;
+          const stretch = 0.8 + ((Math.sin(theta * 2.2) + 1) * 0.22);
+
+          aura.draw2d.image(image, x, y, {
+            width: 20,
+            height: 20,
+            originX: 0.5,
+            originY: 0.5,
+            rotation: theta,
+            scaleX: unit.baseScale * stretch,
+            scaleY: unit.baseScale / stretch,
+            alpha: 0.9,
+          });
+        }
+      };
+    `,
+  },
+  {
+    id: 'math_collision',
+    frames: 300,
+    source: `
+      let accumulator = 0;
+
+      aura.update = function () {
+        for (let i = 0; i < 500; i += 1) {
+          const t = (i % 100) / 100;
+          const v = aura.math.lerp(0, 500, t);
+          const d = aura.math.distance(0, 0, v, v / 2);
+          const hit = aura.collide.rects(v, v, 10, 10, v + 2, v + 2, 8, 8);
+          if (hit) {
+            accumulator += d;
+          }
+        }
+      };
+
+      aura.draw = function () {
+        aura.draw2d.clear(0, 0, 0);
+        aura.draw2d.text(String(accumulator), 4, 4, { color: aura.colors.white, size: 12 });
+      };
+    `,
+  },
+];
+
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function stdDev(values) {
+  if (values.length === 0) return 0;
+  const avg = mean(values);
+  const variance = mean(values.map((value) => (value - avg) ** 2));
+  return Math.sqrt(variance);
+}
+
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  return sorted[mid];
+}
+
+function percentile(values, percentileValue) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const clampedPercentile = Math.max(0, Math.min(100, percentileValue));
+  const rank = (clampedPercentile / 100) * (sorted.length - 1);
+  const lowerIndex = Math.floor(rank);
+  const upperIndex = Math.ceil(rank);
+  if (lowerIndex === upperIndex) {
+    return sorted[lowerIndex];
+  }
+  const weight = rank - lowerIndex;
+  return sorted[lowerIndex] * (1 - weight) + sorted[upperIndex] * weight;
+}
+
+function countStutterBursts(frameTimes, thresholdMs) {
+  let bursts = 0;
+  let inBurst = false;
+  for (const frameTime of frameTimes) {
+    if (frameTime > thresholdMs) {
+      if (!inBurst) {
+        bursts += 1;
+        inBurst = true;
+      }
+      continue;
+    }
+    inBurst = false;
+  }
+  return bursts;
+}
+
+function measureCallLatency(fn, iterations = 250000) {
+  const started = process.hrtime.bigint();
+  for (let i = 0; i < iterations; i += 1) {
+    fn();
+  }
+  const ended = process.hrtime.bigint();
+  const totalNs = Number(ended - started);
+  return (totalNs / iterations) / 1_000_000;
+}
+
+function syntheticLatencies() {
+  const inputState = { down: false };
+  const audioState = { level: 1 };
+
+  const inputLatencyMs = measureCallLatency(() => inputState.down);
+
+  const audioLatencyMs = measureCallLatency(() => {
+    audioState.level = audioState.level > 0.99 ? 0 : audioState.level + 0.01;
+    return audioState.level;
+  });
+
+  return {
+    inputQueryMs: inputLatencyMs,
+    audioCallMs: audioLatencyMs,
+  };
+}
+
+function collectRuntimeCacheDiagnosticsVector() {
+  return {
+    status: 'fail',
+    reasonCode: 'runtime_cache_diag_missing',
+    vectors: null,
+  };
+}
+
+function buildPerfSlice(frameTimes = [], elapsedMs = null, options = {}) {
+  const stutterThresholdMs = Number.isFinite(options.stutterThresholdMs)
+    ? Number(options.stutterThresholdMs)
+    : DEFAULT_STUTTER_THRESHOLD_MS;
+  return {
+    elapsedMs,
+    sampleCount: frameTimes.length,
+    frameTimeSamplesMs: frameTimes,
+    avgFrameTimeMs: mean(frameTimes),
+    medianFrameTimeMs: median(frameTimes),
+    p50FrameTimeMs: percentile(frameTimes, 50),
+    p95FrameTimeMs: percentile(frameTimes, 95),
+    p99FrameTimeMs: percentile(frameTimes, 99),
+    jitterMs: stdDev(frameTimes),
+    stutterBurstCount: countStutterBursts(frameTimes, stutterThresholdMs),
+    stutterThresholdMs,
+    avgFps: mean(frameTimes) === 0 ? 0 : 1000 / mean(frameTimes),
+  };
+}
+
+function pushSliceFailures({ failures, sliceName, slice, limits, sceneId }) {
+  if (!limits || !slice) return;
+  if (typeof limits.maxAvgFrameTimeMs === 'number' && slice.avgFrameTimeMs > limits.maxAvgFrameTimeMs) {
+    failures.push({
+      type: `${sliceName}.scene.avgFrameTimeMs`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.avgFrameTimeMs,
+      threshold: limits.maxAvgFrameTimeMs,
+    });
+  }
+  if (typeof limits.maxJitterMs === 'number' && slice.jitterMs > limits.maxJitterMs) {
+    failures.push({
+      type: `${sliceName}.scene.jitterMs`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.jitterMs,
+      threshold: limits.maxJitterMs,
+    });
+  }
+  if (typeof limits.minFps === 'number' && slice.avgFps < limits.minFps) {
+    failures.push({
+      type: `${sliceName}.scene.avgFps`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.avgFps,
+      threshold: limits.minFps,
+    });
+  }
+  if (typeof limits.maxP50FrameTimeMs === 'number' && slice.p50FrameTimeMs > limits.maxP50FrameTimeMs) {
+    failures.push({
+      type: `${sliceName}.scene.p50FrameTimeMs`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.p50FrameTimeMs,
+      threshold: limits.maxP50FrameTimeMs,
+    });
+  }
+  if (typeof limits.maxP95FrameTimeMs === 'number' && slice.p95FrameTimeMs > limits.maxP95FrameTimeMs) {
+    failures.push({
+      type: `${sliceName}.scene.p95FrameTimeMs`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.p95FrameTimeMs,
+      threshold: limits.maxP95FrameTimeMs,
+    });
+  }
+  if (typeof limits.maxP99FrameTimeMs === 'number' && slice.p99FrameTimeMs > limits.maxP99FrameTimeMs) {
+    failures.push({
+      type: `${sliceName}.scene.p99FrameTimeMs`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.p99FrameTimeMs,
+      threshold: limits.maxP99FrameTimeMs,
+    });
+  }
+  if (typeof limits.maxStutterBurstCount === 'number' && slice.stutterBurstCount > limits.maxStutterBurstCount) {
+    failures.push({
+      type: `${sliceName}.scene.stutterBurstCount`,
+      section: sliceName,
+      scene: sceneId,
+      actual: slice.stutterBurstCount,
+      threshold: limits.maxStutterBurstCount,
+    });
+  }
+}
+
+export function loadPerfThresholds(thresholdPath = null) {
+  const resolvedPath = thresholdPath
+    ? resolve(thresholdPath)
+    : resolve(new URL('../benchmarks/perf-thresholds.json', import.meta.url).pathname);
+
+  const raw = JSON.parse(readFileSync(resolvedPath, 'utf8'));
+  return {
+    path: resolvedPath,
+    thresholds: raw,
+  };
+}
+
+export function evaluatePerfReport(report, thresholds) {
+  const failures = [];
+  const reportSceneIds = new Set((report.scenes || []).map((scene) => scene.id));
+
+  if (thresholds.scenePolicy?.requireAllConfiguredScenes === true) {
+    for (const sceneId of Object.keys(thresholds.scenes || {})) {
+      if (!reportSceneIds.has(sceneId)) {
+        failures.push({
+          type: 'scene.missing',
+          section: 'overall',
+          scene: sceneId,
+          actual: 'missing',
+          threshold: 'present-in-report',
+        });
+      }
+    }
+  }
+
+  for (const scene of report.scenes || []) {
+    const overallLimits = thresholds.scenes?.[scene.id];
+    if (overallLimits) {
+      if (scene.avgFrameTimeMs > overallLimits.maxAvgFrameTimeMs) {
+        failures.push({
+          type: 'scene.avgFrameTimeMs',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.avgFrameTimeMs,
+          threshold: overallLimits.maxAvgFrameTimeMs,
+        });
+      }
+      if (scene.jitterMs > overallLimits.maxJitterMs) {
+        failures.push({
+          type: 'scene.jitterMs',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.jitterMs,
+          threshold: overallLimits.maxJitterMs,
+        });
+      }
+      if (scene.avgFps < overallLimits.minFps) {
+        failures.push({
+          type: 'scene.avgFps',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.avgFps,
+          threshold: overallLimits.minFps,
+        });
+      }
+      if (typeof overallLimits.maxP50FrameTimeMs === 'number' && scene.p50FrameTimeMs > overallLimits.maxP50FrameTimeMs) {
+        failures.push({
+          type: 'scene.p50FrameTimeMs',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.p50FrameTimeMs,
+          threshold: overallLimits.maxP50FrameTimeMs,
+        });
+      }
+      if (typeof overallLimits.maxP95FrameTimeMs === 'number' && scene.p95FrameTimeMs > overallLimits.maxP95FrameTimeMs) {
+        failures.push({
+          type: 'scene.p95FrameTimeMs',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.p95FrameTimeMs,
+          threshold: overallLimits.maxP95FrameTimeMs,
+        });
+      }
+      if (typeof overallLimits.maxP99FrameTimeMs === 'number' && scene.p99FrameTimeMs > overallLimits.maxP99FrameTimeMs) {
+        failures.push({
+          type: 'scene.p99FrameTimeMs',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.p99FrameTimeMs,
+          threshold: overallLimits.maxP99FrameTimeMs,
+        });
+      }
+      if (typeof overallLimits.maxStutterBurstCount === 'number' && scene.stutterBurstCount > overallLimits.maxStutterBurstCount) {
+        failures.push({
+          type: 'scene.stutterBurstCount',
+          section: 'overall',
+          scene: scene.id,
+          actual: scene.stutterBurstCount,
+          threshold: overallLimits.maxStutterBurstCount,
+        });
+      }
+    }
+
+    pushSliceFailures({
+      failures,
+      sliceName: 'coldStart',
+      slice: scene.coldStart,
+      limits: thresholds.coldStart?.scenes?.[scene.id],
+      sceneId: scene.id,
+    });
+    pushSliceFailures({
+      failures,
+      sliceName: 'warmCache',
+      slice: scene.warmCache,
+      limits: thresholds.warmCache?.scenes?.[scene.id],
+      sceneId: scene.id,
+    });
+  }
+
+  if (typeof thresholds.latency?.maxInputQueryMs === 'number'
+      && report.latency.inputQueryMs > thresholds.latency.maxInputQueryMs) {
+    failures.push({
+      type: 'latency.inputQueryMs',
+      section: 'latency',
+      actual: report.latency.inputQueryMs,
+      threshold: thresholds.latency.maxInputQueryMs,
+    });
+  }
+
+  if (typeof thresholds.latency?.maxAudioCallMs === 'number'
+      && report.latency.audioCallMs > thresholds.latency.maxAudioCallMs) {
+    failures.push({
+      type: 'latency.audioCallMs',
+      section: 'latency',
+      actual: report.latency.audioCallMs,
+      threshold: thresholds.latency.maxAudioCallMs,
+    });
+  }
+
+  if (thresholds.runtimeCacheDiagnostics?.requirePass === true
+      && (report.runtimeCacheDiagnostics?.status || 'fail') !== 'pass') {
+    failures.push({
+      type: 'runtimeCacheDiagnostics',
+      section: 'runtimeCacheDiagnostics',
+      reasonCode: report.runtimeCacheDiagnostics?.reasonCode || 'runtime_cache_diag_missing',
+      actual: report.runtimeCacheDiagnostics?.status || 'missing',
+      threshold: 'pass',
+    });
+  }
+
+  return failures;
+}
+
+export async function runPerfBenchmarks(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const workspaceRoot = resolve(projectRoot, options.workspaceRoot || DEFAULT_PERF_WORKSPACE_ROOT);
+  const reportPath = resolve(projectRoot, options.reportPath || DEFAULT_PERF_REPORT_PATH);
+  const scenes = options.scenes || DEFAULT_PERF_SCENES;
+  const repeats = Number.isInteger(options.repeats) && options.repeats > 0 ? options.repeats : 5;
+  const assetMode = options.assetMode || process.env.AURA_PERF_ASSET_MODE || 'embed';
+  const stutterThresholdMs = Number.isFinite(options.stutterThresholdMs)
+    ? Number(options.stutterThresholdMs)
+    : DEFAULT_STUTTER_THRESHOLD_MS;
+
+  mkdirSync(resolve(workspaceRoot, 'src'), { recursive: true });
+
+  const sceneReports = [];
+
+  for (const scene of scenes) {
+    const entryRelative = `src/${scene.id}.js`;
+    const entryAbsolute = resolve(workspaceRoot, entryRelative);
+    writeFileSync(entryAbsolute, scene.source.trimStart(), 'utf8');
+
+    const samplesMs = [];
+
+    for (let run = 0; run < repeats; run += 1) {
+      const started = process.hrtime.bigint();
+      await runHeadlessTest({
+        projectRoot: workspaceRoot,
+        file: entryRelative,
+        frames: scene.frames,
+        width: scene.width ?? 1280,
+        height: scene.height ?? 720,
+      });
+      const ended = process.hrtime.bigint();
+      samplesMs.push(Number(ended - started) / 1_000_000);
+    }
+
+    const frameTimes = samplesMs.map((elapsed) => elapsed / scene.frames);
+    const coldStartFrameTimes = frameTimes.length > 0 ? [frameTimes[0]] : [];
+    const warmCacheFrameTimes = frameTimes.slice(1);
+
+    const coldStart = buildPerfSlice(coldStartFrameTimes, samplesMs[0] ?? null, { stutterThresholdMs });
+    const warmCache = buildPerfSlice(
+      warmCacheFrameTimes,
+      warmCacheFrameTimes.length > 0 ? mean(samplesMs.slice(1)) : null,
+      { stutterThresholdMs },
+    );
+    const fullSlice = buildPerfSlice(frameTimes, mean(samplesMs), { stutterThresholdMs });
+
+    sceneReports.push({
+      id: scene.id,
+      scenario: scene.id,
+      assetMode,
+      frames: scene.frames,
+      repeats,
+      frameTimeSamplesMs: frameTimes,
+      avgFrameTimeMs: mean(frameTimes),
+      medianFrameTimeMs: median(frameTimes),
+      p50FrameTimeMs: fullSlice.p50FrameTimeMs,
+      p95FrameTimeMs: fullSlice.p95FrameTimeMs,
+      p99FrameTimeMs: fullSlice.p99FrameTimeMs,
+      jitterMs: stdDev(frameTimes),
+      stutterBurstCount: fullSlice.stutterBurstCount,
+      stutterThresholdMs,
+      avgFps: mean(frameTimes) === 0 ? 0 : 1000 / mean(frameTimes),
+      coldStart,
+      warmCache,
+    });
+  }
+
+  const latency = syntheticLatencies();
+  const hostBinary = resolveGateHostBinary({ searchFrom: projectRoot });
+
+  const report = {
+    schemaVersion: PERF_REPORT_SCHEMA,
+    generatedAt: new Date().toISOString(),
+    environment: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch,
+    },
+    config: {
+      repeats,
+      sceneCount: scenes.length,
+      slices: ['coldStart', 'warmCache'],
+      stutterThresholdMs,
+      assetMode,
+    },
+    hostBinary: {
+      path: hostBinary.binaryPath,
+      packageName: hostBinary.packageName || null,
+      source: hostBinary.source || null,
+      diagnostics: hostBinary.diagnostics || [],
+      target: hostBinary.target || null,
+      resolvedAt: hostBinary.resolvedAt || null,
+      localBuild: hostBinary.localBuild || null,
+    },
+    scenes: sceneReports,
+    latency,
+    runtimeCacheDiagnostics: collectRuntimeCacheDiagnosticsVector(),
+  };
+
+  mkdirSync(dirname(reportPath), { recursive: true });
+  writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+
+  return {
+    ...report,
+    reportPath,
+    workspaceRoot,
+  };
+}

package/src/postinstall.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { resolveAndCacheHostBinary, HostBinaryResolutionError } from './host-binary.mjs';
+
+function main() {
+  const pkgPath = new URL('../package.json', import.meta.url);
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+
+  try {
+    const result = resolveAndCacheHostBinary({ packageJsonVersion: pkg.version });
+    console.log(`[aurajs] host binary ready (${result.target}): ${result.binaryPath}`);
+    if (result.cacheStatus !== 'hit') {
+      console.log(`[aurajs] cache ${result.cacheStatus}: ${result.cacheDir}`);
+    }
+  } catch (error) {
+    if (error instanceof HostBinaryResolutionError) {
+      console.error(`[aurajs] postinstall warning: ${error.message}`);
+      console.error('[aurajs] run "npm install" again after optionalDependencies are available.');
+      process.exit(0);
+    }
+    throw error;
+  }
+}
+
+main();

package/src/scaffold.mjs

@@ -0,0 +1,74 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const TEMPLATES_DIR = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '../templates/starter'
+);
+
+/**
+ * Scaffold a new AuraJS project.
+ * @param {string} name - Project name (used as directory name and in config).
+ * @param {string} dest - Absolute path to create the project at.
+ */
+export function scaffold(name, dest) {
+  if (existsSync(dest)) {
+    const entries = readdirSync(dest);
+    if (entries.length > 0) {
+      throw new Error(`Directory "${name}" already exists and is not empty.`);
+    }
+  }
+
+  // Copy template tree, replacing {{PROJECT_NAME}} placeholders.
+  copyTree(TEMPLATES_DIR, dest, { PROJECT_NAME: name });
+
+  // Ensure assets/ directory exists (even if empty in template).
+  mkdirSync(join(dest, 'assets'), { recursive: true });
+
+  return {
+    dest,
+    files: listFiles(dest),
+  };
+}
+
+/**
+ * Recursively copy a directory tree, applying placeholder replacements
+ * to text files.
+ */
+function copyTree(src, dest, replacements) {
+  mkdirSync(dest, { recursive: true });
+
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      copyTree(srcPath, destPath, replacements);
+    } else {
+      let content = readFileSync(srcPath, 'utf8');
+      for (const [key, value] of Object.entries(replacements)) {
+        content = content.replaceAll(`{{${key}}}`, value);
+      }
+      writeFileSync(destPath, content, 'utf8');
+    }
+  }
+}
+
+/**
+ * List all files in a directory tree (relative paths).
+ */
+function listFiles(dir, prefix = '') {
+  const files = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const rel = prefix ? `${prefix}/${entry}` : entry;
+    if (statSync(full).isDirectory()) {
+      files.push(...listFiles(full, rel));
+    } else {
+      files.push(rel);
+    }
+  }
+  return files;
+}

package/templates/starter/aura.config.json

@@ -0,0 +1,28 @@
+{
+  "identity": {
+    "name": "{{PROJECT_NAME}}",
+    "version": "0.1.0",
+    "executable": "game",
+    "icon": null
+  },
+  "window": {
+    "title": "{{PROJECT_NAME}}",
+    "width": 1280,
+    "height": 720,
+    "resizable": true,
+    "fullscreen": false,
+    "vsync": true,
+    "hidpi": true
+  },
+  "build": {
+    "entry": "src/main.js",
+    "outDir": "build",
+    "assetDir": "assets",
+    "assetMode": "embed"
+  },
+  "modules": {
+    "physics": false,
+    "network": false,
+    "steam": false
+  }
+}