fastly-spa-yolo 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fastly-spa-yolo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# fastly-spa-yolo
+
+Deploy a tiny built SPA to Fastly Compute by embedding the whole output folder into the Rust/Wasm package.
+
+Bad idea. Works great.
+
+This is for prototypes, demos, hackathon apps, vibe-coded experiments, internal previews, and the moment where you already have a `dist/` folder and just need a URL.
+
+## What it does
+
+From an existing SPA project, this creates an isolated Fastly Compute Rust project in `.fastly-spa-yolo/`.
+
+```txt
+my-spa/
+  package.json
+  src/
+  dist/
+    index.html
+    assets/app.abcdef12.js
+    assets/app.css
+
+  .fastly-spa-yolo/
+    Cargo.toml
+    fastly.toml
+    rust-toolchain.toml
+    src/
+      main.rs
+      assets.rs
+      yolo_config.rs
+    config.json
+```
+
+The generated Rust keeps the Fastly handler in `src/main.rs` and puts the variable generated bits in tiny side files. `src/assets.rs` owns the `rust-embed` folder path:
+
+```rust
+#[derive(Embed)]
+#[folder = "../dist/"]
+pub struct Asset;
+```
+
+Then requests are served directly from the embedded asset map.
+
+```txt
+/                         -> index.html
+/index.html                -> index.html
+/assets/app.abcdef12.js    -> embedded JS asset
+/dashboard                 -> index.html, SPA fallback
+/assets/missing.js         -> 404
+/__yolo                    -> build metadata JSON
+```
+
+## Install / initialize
+
+From an existing SPA project root:
+
+```bash
+npx fastly-spa-yolo init
+```
+
+For no prompts:
+
+```bash
+npx fastly-spa-yolo init --yes
+```
+
+With explicit output folder:
+
+```bash
+npx fastly-spa-yolo init --yes --dist build
+```
+
+## Generated npm scripts
+
+By default, `init` patches your root `package.json` with:
+
+```json
+{
+  "scripts": {
+    "yolo:init": "npx --yes fastly-spa-yolo init",
+    "yolo:build": "npx --yes fastly-spa-yolo build",
+    "yolo:serve": "npx --yes fastly-spa-yolo serve",
+    "yolo:deploy": "npx --yes fastly-spa-yolo deploy"
+  }
+}
+```
+
+Skip that with:
+
+```bash
+npx fastly-spa-yolo init --no-scripts
+```
+
+## Commands
+
+### `init`
+
+Generates `.fastly-spa-yolo/`.
+
+```bash
+npx fastly-spa-yolo init
+```
+
+Useful flags:
+
+```txt
+--yes, -y                 accept inferred defaults
+--force, -f               overwrite generated files
+--dist <dir>              SPA build output folder
+--build-command <cmd>     app build command
+--name <name>             Fastly/Cargo package name
+--compute-dir <dir>       generated project dir
+--no-scripts              do not patch package.json
+--no-spa-fallback         disable unknown route fallback to index.html
+```
+
+### `build`
+
+Runs the app build, checks the dist folder, hashes it, then runs `fastly compute build` inside `.fastly-spa-yolo/`.
+
+```bash
+npm run yolo:build
+```
+
+Pass Fastly CLI args after `--`:
+
+```bash
+npm run yolo:build -- --verbose
+```
+
+### `serve`
+
+Runs the app build, then serves locally through Fastly Compute:
+
+```bash
+npm run yolo:serve
+```
+
+Pass Fastly CLI args after `--`:
+
+```bash
+npm run yolo:serve -- --watch
+```
+
+### `deploy`
+
+Runs the app build, then runs `fastly compute publish` inside `.fastly-spa-yolo/`.
+
+```bash
+npm run yolo:deploy
+```
+
+Non-interactive Fastly defaults:
+
+```bash
+npm run yolo:deploy -- --accept-defaults
+```
+
+### `hash-dist`
+
+Prints the SHA-256 hash of the configured dist folder.
+
+```bash
+npx fastly-spa-yolo hash-dist
+```
+
+### `doctor`
+
+Prints basic environment/project checks.
+
+```bash
+npx fastly-spa-yolo doctor
+```
+
+## Cache behavior
+
+The generated Compute app uses this deliberately simple policy:
+
+```txt
+index.html                 Cache-Control: no-cache
+assets with hex hashes      Cache-Control: public, max-age=31536000, immutable
+other static assets         Cache-Control: public, max-age=60
+```
+
+Every response gets:
+
+```txt
+X-Yolo-Build: <dist hash prefix>
+ETag: "yolo-<build>-<path>"
+```
+
+`/__yolo` returns something like:
+
+```json
+{
+  "name": "my-app-yolo",
+  "build": "a1b2c3d4e5f6",
+  "assets": 3,
+  "mode": "embedded-spa-yolo"
+}
+```
+
+## Requirements
+
+You need:
+
+- Node.js 18+
+- Fastly CLI
+- Rust / Cargo / rustup
+
+The generated Compute project pins `wasm32-wasip1` and uses a build script that copies the compiled Wasm to `bin/main.wasm`.
+
+## Caveats
+
+This embeds static files into the Compute package. Every asset change means a new Wasm build and Fastly deploy.
+
+That is the point.
+
+For large sites, serious static hosting, or content-only deploys, use a real static pipeline or Fastly's KV-based static publishing tooling instead.

package/bin/fastly-spa-yolo.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { main } from '../src/cli.js';
+
+main(process.argv.slice(2)).catch((err) => {
+  const message = err && err.message ? err.message : String(err);
+  console.error(`fastly-spa-yolo: ${message}`);
+  if (err && err.hint) console.error(`hint: ${err.hint}`);
+  process.exitCode = err && Number.isInteger(err.exitCode) ? err.exitCode : 1;
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "fastly-spa-yolo",
+  "version": "0.0.2",
+  "description": "YOLO deploy tiny SPA builds to Fastly Compute by embedding dist into Rust/Wasm.",
+  "type": "module",
+  "bin": {
+    "fastly-spa-yolo": "bin/fastly-spa-yolo.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "lint:syntax": "node --check bin/fastly-spa-yolo.js && node --check src/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "fastly",
+    "compute",
+    "spa",
+    "static",
+    "edge",
+    "yolo"
+  ],
+  "author": "",
+  "license": "MIT"
+}

package/src/cli.js

@@ -0,0 +1,789 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import readline from 'node:readline/promises';
+import process from 'node:process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const TEMPLATE_DIR = path.join(PACKAGE_ROOT, 'templates');
+
+const CLI_VERSION = '0.0.2';
+const DEFAULT_COMPUTE_DIR = '.fastly-spa-yolo';
+const CONFIG_FILE = 'config.json';
+const GENERATED_HEADER = 'Generated by fastly-spa-yolo. Hack responsibly.';
+
+export async function main(argv = process.argv.slice(2)) {
+  const parsed = parseArgv(argv);
+
+  if (parsed.flags.version || parsed.command === 'version') {
+    console.log(CLI_VERSION);
+    return;
+  }
+
+  if (parsed.flags.help || parsed.command === 'help' || !parsed.command) {
+    printHelp();
+    return;
+  }
+
+  switch (parsed.command) {
+    case 'init':
+      await initCommand(parsed.flags);
+      return;
+    case 'build':
+      await buildCommand(parsed.flags, parsed.passthrough);
+      return;
+    case 'serve':
+      await serveCommand(parsed.flags, parsed.passthrough);
+      return;
+    case 'deploy':
+    case 'publish':
+      await deployCommand(parsed.flags, parsed.passthrough);
+      return;
+    case 'hash-dist':
+    case 'hash':
+      await hashDistCommand(parsed.flags);
+      return;
+    case 'doctor':
+      await doctorCommand(parsed.flags);
+      return;
+    default:
+      throw usageError(`unknown command: ${parsed.command}`, 'Run: fastly-spa-yolo --help');
+  }
+}
+
+function printHelp() {
+  console.log(`fastly-spa-yolo ${CLI_VERSION}
+
+YOLO deploy a tiny SPA to Fastly Compute by embedding the build output into Rust/Wasm.
+
+Usage:
+  fastly-spa-yolo init [options]
+  fastly-spa-yolo build [options] [-- fastly compute build args]
+  fastly-spa-yolo serve [options] [-- fastly compute serve args]
+  fastly-spa-yolo deploy [options] [-- fastly compute publish args]
+  fastly-spa-yolo hash-dist [options]
+  fastly-spa-yolo doctor
+
+Common init options:
+  --yes, -y                 Accept inferred defaults
+  --force, -f               Overwrite existing .fastly-spa-yolo files
+  --dist <dir>              SPA build output folder, default inferred or dist
+  --build-command <cmd>     App build command, default inferred from package.json
+  --name <name>             Fastly/Cargo package name, default from package.json
+  --compute-dir <dir>       Generated Compute project dir, default .fastly-spa-yolo
+  --no-scripts              Do not patch package.json scripts
+  --no-spa-fallback         Disable SPA fallback to index.html
+
+Common run options:
+  --skip-app-build          Do not run the app build before Fastly build/serve/deploy
+  --compute-dir <dir>       Generated Compute project dir
+
+Examples:
+  npx fastly-spa-yolo init
+  npm run yolo:serve
+  npm run yolo:deploy -- --accept-defaults
+`);
+}
+
+async function initCommand(flags) {
+  const root = path.resolve(String(flags.cwd || process.cwd()));
+  const pkgPath = path.join(root, 'package.json');
+  const pkg = await readJsonIfExists(pkgPath);
+
+  if (!pkg) {
+    throw usageError(
+      'no package.json found in the current directory',
+      'Run fastly-spa-yolo from the root of an existing SPA project.'
+    );
+  }
+
+  const packageManager = await inferPackageManager(root, pkg);
+  const defaultBuildCommand = inferBuildCommand(pkg, packageManager);
+  const defaultDistDir = await inferDistDir(root, pkg);
+  const defaultName = sanitizePackageBase(String(pkg.name || path.basename(root) || 'spa')) + '-yolo';
+  const defaultVersion = normalizeVersion(pkg.version || '0.0.1');
+  const defaultComputeDir = String(flags.computeDir || DEFAULT_COMPUTE_DIR);
+
+  const yes = Boolean(flags.yes || flags.y);
+  const force = Boolean(flags.force || flags.f);
+
+  let distDir = String(flags.dist || defaultDistDir);
+  let buildCommand = String(flags.buildCommand || defaultBuildCommand || 'npm run build');
+  let fastlyName = sanitizePackageName(String(flags.name || defaultName));
+  let computeDirRel = normalizeRelativeDir(defaultComputeDir);
+  let spaFallback = flags.spaFallback !== false;
+
+  if (!yes) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      distDir = await askText(rl, 'Static output folder', distDir);
+      buildCommand = await askText(rl, 'Build command', buildCommand);
+      fastlyName = sanitizePackageName(await askText(rl, 'Fastly package name', fastlyName));
+      computeDirRel = normalizeRelativeDir(await askText(rl, 'Generated Compute directory', computeDirRel));
+      spaFallback = await askYesNo(rl, 'Fallback unknown extensionless routes to index.html', spaFallback);
+    } finally {
+      rl.close();
+    }
+  }
+
+  distDir = normalizeRelativeDir(distDir);
+  const computeDir = path.resolve(root, computeDirRel);
+
+  if (await exists(computeDir)) {
+    if (!force) {
+      throw usageError(
+        `${computeDirRel} already exists`,
+        'Pass --force to overwrite generated files.'
+      );
+    }
+  }
+
+  const distAbs = path.resolve(root, distDir);
+  const embedFolder = toPosixPath(path.relative(computeDir, distAbs));
+  const cargoPackageName = sanitizePackageName(fastlyName);
+  const cargoVersion = defaultVersion;
+
+  const config = {
+    version: 1,
+    generatedBy: `fastly-spa-yolo@${CLI_VERSION}`,
+    computeDir: computeDirRel,
+    distDir,
+    buildCommand,
+    fastlyName,
+    cargoPackageName,
+    cargoVersion,
+    spaFallback,
+    createdAt: new Date().toISOString()
+  };
+
+  await fs.mkdir(path.join(computeDir, 'src'), { recursive: true });
+  await fs.mkdir(path.join(computeDir, 'scripts'), { recursive: true });
+  await fs.mkdir(path.join(computeDir, '.cargo'), { recursive: true });
+
+  await writeGenerated(path.join(computeDir, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`, force);
+  await writeGenerated(path.join(computeDir, 'Cargo.toml'), renderCargoToml(config), force);
+  await writeGenerated(path.join(computeDir, 'fastly.toml'), renderFastlyToml(config), force);
+  await writeGenerated(path.join(computeDir, 'rust-toolchain.toml'), renderRustToolchainToml(), force);
+  await writeGenerated(path.join(computeDir, '.cargo', 'config.toml'), renderCargoConfigToml(), force);
+  await writeGenerated(path.join(computeDir, 'src', 'main.rs'), await renderMainRs(), force);
+  await writeGenerated(path.join(computeDir, 'src', 'assets.rs'), await renderAssetsRs({ embedFolder }), force);
+  await writeGenerated(path.join(computeDir, 'src', 'yolo_config.rs'), await renderYoloConfigRs({ spaFallback }), force);
+  await writeGenerated(path.join(computeDir, 'scripts', 'copy-wasm.cjs'), renderCopyWasmScript(), force);
+  await writeGenerated(path.join(computeDir, '.gitignore'), renderComputeGitignore(), force);
+  await writeGenerated(path.join(computeDir, 'README.md'), renderComputeReadme(config), force);
+
+  if (flags.scripts !== false) {
+    await patchPackageJsonScripts(pkgPath, pkg);
+  }
+
+  console.log(`\nfastly-spa-yolo initialized in ${computeDirRel}`);
+  console.log(`dist: ${distDir}`);
+  console.log(`build: ${buildCommand}`);
+  console.log('\nNext:');
+  console.log('  npm run yolo:serve');
+  console.log('  npm run yolo:deploy');
+}
+
+async function buildCommand(flags, passthrough) {
+  const ctx = await loadContext(flags);
+  await maybeRunAppBuild(ctx, flags);
+  const env = await computeBuildEnv(ctx);
+  await runFastly(['compute', 'build', ...passthrough], { cwd: ctx.computeDir, env });
+}
+
+async function serveCommand(flags, passthrough) {
+  const ctx = await loadContext(flags);
+  await maybeRunAppBuild(ctx, flags);
+  const env = await computeBuildEnv(ctx);
+  await runFastly(['compute', 'serve', ...passthrough], { cwd: ctx.computeDir, env });
+}
+
+async function deployCommand(flags, passthrough) {
+  const ctx = await loadContext(flags);
+  await maybeRunAppBuild(ctx, flags);
+  const env = await computeBuildEnv(ctx);
+  await runFastly(['compute', 'publish', ...passthrough], { cwd: ctx.computeDir, env });
+}
+
+async function hashDistCommand(flags) {
+  let distAbs;
+
+  if (flags.dist) {
+    distAbs = path.resolve(String(flags.cwd || process.cwd()), String(flags.dist));
+  } else {
+    const ctx = await loadContext(flags);
+    distAbs = path.resolve(ctx.root, ctx.config.distDir);
+  }
+
+  await assertDistReady(distAbs);
+  console.log(await hashDirectory(distAbs));
+}
+
+async function doctorCommand(flags) {
+  const root = path.resolve(String(flags.cwd || process.cwd()));
+  const pkg = await readJsonIfExists(path.join(root, 'package.json'));
+
+  console.log('fastly-spa-yolo doctor');
+  console.log(`root: ${root}`);
+  console.log(`package.json: ${pkg ? 'ok' : 'missing'}`);
+
+  const fastly = commandVersion('fastly', ['--version']);
+  const cargo = commandVersion('cargo', ['--version']);
+  const rustup = commandVersion('rustup', ['--version']);
+
+  console.log(`fastly: ${fastly.ok ? fastly.version : 'missing'}`);
+  console.log(`cargo: ${cargo.ok ? cargo.version : 'missing'}`);
+  console.log(`rustup: ${rustup.ok ? rustup.version : 'missing'}`);
+
+  try {
+    const ctx = await loadContext(flags);
+    const distAbs = path.resolve(ctx.root, ctx.config.distDir);
+    const distOk = await exists(distAbs);
+    const indexOk = await exists(path.join(distAbs, 'index.html'));
+    console.log(`compute dir: ${ctx.config.computeDir}`);
+    console.log(`dist dir: ${ctx.config.distDir} ${distOk ? 'ok' : 'missing'}`);
+    console.log(`index.html: ${indexOk ? 'ok' : 'missing'}`);
+  } catch (err) {
+    console.log('config: missing; run fastly-spa-yolo init');
+  }
+}
+
+async function loadContext(flags) {
+  const root = path.resolve(String(flags.cwd || process.cwd()));
+  const computeDirRel = normalizeRelativeDir(String(flags.computeDir || DEFAULT_COMPUTE_DIR));
+  const computeDir = path.resolve(root, computeDirRel);
+  const configPath = path.join(computeDir, CONFIG_FILE);
+  const config = await readJsonIfExists(configPath);
+
+  if (!config) {
+    throw usageError(
+      `no ${CONFIG_FILE} found in ${computeDirRel}`,
+      'Run fastly-spa-yolo init first.'
+    );
+  }
+
+  return { root, computeDir, configPath, config };
+}
+
+async function maybeRunAppBuild(ctx, flags) {
+  if (flags.skipAppBuild) {
+    const distAbs = path.resolve(ctx.root, ctx.config.distDir);
+    await assertDistReady(distAbs);
+    return;
+  }
+
+  const command = String(ctx.config.buildCommand || '').trim();
+  if (!command) {
+    throw usageError('no build command configured', `Edit ${ctx.config.computeDir}/${CONFIG_FILE}.`);
+  }
+
+  console.log(`\n$ ${command}`);
+  await runShell(command, { cwd: ctx.root, env: process.env });
+
+  const distAbs = path.resolve(ctx.root, ctx.config.distDir);
+  await assertDistReady(distAbs);
+}
+
+async function computeBuildEnv(ctx) {
+  const distAbs = path.resolve(ctx.root, ctx.config.distDir);
+  await assertDistReady(distAbs);
+
+  const hash = await hashDirectory(distAbs);
+  const shortHash = hash.slice(0, 12);
+
+  return {
+    ...process.env,
+    FASTLY_SPA_YOLO_BUILD_ID: shortHash,
+    FASTLY_SPA_YOLO_DIST_HASH: hash,
+    FASTLY_SPA_YOLO_APP_NAME: ctx.config.fastlyName || 'fastly-spa-yolo'
+  };
+}
+
+async function assertDistReady(distAbs) {
+  if (!(await exists(distAbs))) {
+    throw usageError(`dist folder not found: ${distAbs}`, 'Run your SPA build first, or update .fastly-spa-yolo/config.json.');
+  }
+
+  const indexPath = path.join(distAbs, 'index.html');
+  if (!(await exists(indexPath))) {
+    throw usageError(`index.html not found in ${distAbs}`, 'fastly-spa-yolo expects an SPA build folder with index.html.');
+  }
+}
+
+async function patchPackageJsonScripts(pkgPath, pkg) {
+  pkg.scripts ||= {};
+
+  const additions = {
+    'yolo:init': 'npx --yes fastly-spa-yolo init',
+    'yolo:build': 'npx --yes fastly-spa-yolo build',
+    'yolo:serve': 'npx --yes fastly-spa-yolo serve',
+    'yolo:deploy': 'npx --yes fastly-spa-yolo deploy'
+  };
+
+  let changed = false;
+  for (const [name, value] of Object.entries(additions)) {
+    if (!pkg.scripts[name]) {
+      pkg.scripts[name] = value;
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    await fs.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    console.log('patched package.json scripts');
+  }
+}
+
+async function inferPackageManager(root, pkg) {
+  const declared = typeof pkg.packageManager === 'string' ? pkg.packageManager : '';
+  if (declared.startsWith('pnpm@')) return 'pnpm';
+  if (declared.startsWith('yarn@')) return 'yarn';
+  if (declared.startsWith('bun@')) return 'bun';
+  if (declared.startsWith('npm@')) return 'npm';
+
+  if (await exists(path.join(root, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (await exists(path.join(root, 'yarn.lock'))) return 'yarn';
+  if (await exists(path.join(root, 'bun.lockb')) || await exists(path.join(root, 'bun.lock'))) return 'bun';
+  return 'npm';
+}
+
+function inferBuildCommand(pkg, packageManager) {
+  if (pkg.scripts && typeof pkg.scripts.build === 'string') {
+    switch (packageManager) {
+      case 'pnpm': return 'pnpm run build';
+      case 'yarn': return 'yarn build';
+      case 'bun': return 'bun run build';
+      default: return 'npm run build';
+    }
+  }
+
+  return '';
+}
+
+async function inferDistDir(root, pkg) {
+  const candidatesWithIndex = ['dist', 'build', 'out', 'public', 'docs'];
+  for (const candidate of candidatesWithIndex) {
+    if (await exists(path.join(root, candidate, 'index.html'))) return candidate;
+  }
+
+  const candidatesExisting = ['dist', 'build', 'out'];
+  for (const candidate of candidatesExisting) {
+    if (await exists(path.join(root, candidate))) return candidate;
+  }
+
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+
+  const buildScript = String(pkg.scripts?.build || '').toLowerCase();
+
+  if (deps['react-scripts'] || buildScript.includes('react-scripts build')) return 'build';
+  if (deps.next || buildScript.includes('next export')) return 'out';
+
+  return 'dist';
+}
+
+function renderCargoToml(config) {
+  return `# ${GENERATED_HEADER}
+
+[package]
+name = ${tomlString(config.cargoPackageName)}
+version = ${tomlString(config.cargoVersion)}
+edition = "2021"
+publish = false
+
+[dependencies]
+fastly = "0.12"
+mime_guess = "2"
+rust-embed = { version = "8", features = ["debug-embed"] }
+`;
+}
+
+function renderFastlyToml(config) {
+  const wasmSource = `target/wasm32-wasip1/release/${config.cargoPackageName}.wasm`;
+  const buildCommand = `cargo build --bin ${config.cargoPackageName} --release --target wasm32-wasip1 --color always && node scripts/copy-wasm.cjs ${wasmSource} bin/main.wasm`;
+
+  return `# ${GENERATED_HEADER}
+
+manifest_version = 3
+name = ${tomlString(config.fastlyName)}
+description = "YOLO embedded SPA on Fastly Compute"
+language = "rust"
+authors = []
+
+[scripts]
+build = ${tomlString(buildCommand)}
+`;
+}
+
+function renderRustToolchainToml() {
+  return `# ${GENERATED_HEADER}
+# Pinned away from known-bad future/current Fastly compatibility bumps.
+
+[toolchain]
+channel = "1.90.0"
+targets = ["wasm32-wasip1"]
+`;
+}
+
+function renderCargoConfigToml() {
+  return `# ${GENERATED_HEADER}
+
+[build]
+target = "wasm32-wasip1"
+`;
+}
+
+function renderCopyWasmScript() {
+  return `#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+
+const [source, dest] = process.argv.slice(2);
+if (!source || !dest) {
+  console.error('usage: node scripts/copy-wasm.cjs <source.wasm> <dest.wasm>');
+  process.exit(2);
+}
+
+if (!fs.existsSync(source)) {
+  console.error(` + '`wasm source not found: ${source}`' + `);
+  process.exit(1);
+}
+
+fs.mkdirSync(path.dirname(dest), { recursive: true });
+fs.copyFileSync(source, dest);
+console.log(` + '`copied ${source} -> ${dest}`' + `);
+`;
+}
+
+function renderComputeGitignore() {
+  return `target/
+bin/
+pkg/
+`;
+}
+
+function renderComputeReadme(config) {
+  return `# ${config.fastlyName}
+
+Generated by fastly-spa-yolo.
+
+This Compute project embeds \`${config.distDir}/\` from the parent SPA project into the Rust/Wasm binary.
+
+Run from the project root:
+
+\`\`\`bash
+npm run yolo:serve
+npm run yolo:deploy
+\`\`\`
+
+This is intentionally a YOLO prototype path, not a general static hosting platform.
+`;
+}
+
+async function renderMainRs() {
+  return readTemplate('compute-main.rs');
+}
+
+async function renderAssetsRs({ embedFolder }) {
+  const folder = ensureTrailingSlash(toPosixPath(embedFolder));
+  return renderTemplate('assets.rs.tmpl', {
+    FASTLY_SPA_YOLO_EMBED_FOLDER: folder
+  });
+}
+
+async function renderYoloConfigRs({ spaFallback }) {
+  return renderTemplate('yolo_config.rs.tmpl', {
+    FASTLY_SPA_YOLO_SPA_FALLBACK: spaFallback ? 'true' : 'false'
+  });
+}
+
+async function renderTemplate(name, replacements = {}) {
+  let content = await readTemplate(name);
+
+  for (const [key, value] of Object.entries(replacements)) {
+    content = content.replaceAll(`__${key}__`, String(value));
+  }
+
+  return content;
+}
+
+async function readTemplate(name) {
+  return fs.readFile(path.join(TEMPLATE_DIR, name), 'utf8');
+}
+
+async function hashDirectory(dir) {
+  const files = await listFilesRecursive(dir);
+  const hash = createHash('sha256');
+
+  for (const file of files.sort()) {
+    const abs = path.join(dir, file);
+    hash.update(file.replaceAll('\\\\', '/'));
+    hash.update('\0');
+    await hashFileInto(abs, hash);
+    hash.update('\0');
+  }
+
+  return hash.digest('hex');
+}
+
+async function listFilesRecursive(root, dir = root, out = []) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await listFilesRecursive(root, abs, out);
+    } else if (entry.isFile()) {
+      out.push(toPosixPath(path.relative(root, abs)));
+    }
+  }
+
+  return out;
+}
+
+function hashFileInto(file, hash) {
+  return new Promise((resolve, reject) => {
+    const stream = createReadStream(file);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', resolve);
+  });
+}
+
+function runShell(command, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, {
+      cwd,
+      env,
+      stdio: 'inherit',
+      shell: true
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(commandError(`command failed: ${command}${signal ? ` (${signal})` : ''}`, code ?? 1));
+    });
+  });
+}
+
+function runFastly(args, { cwd, env }) {
+  console.log(`\n$ fastly ${args.join(' ')}`);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('fastly', args, {
+      cwd,
+      env,
+      stdio: 'inherit',
+      shell: process.platform === 'win32'
+    });
+
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        reject(usageError('Fastly CLI not found on PATH', 'Install the Fastly CLI, then run this command again.'));
+      } else {
+        reject(err);
+      }
+    });
+
+    child.on('exit', (code, signal) => {
+      if (code === 0) resolve();
+      else reject(commandError(`fastly ${args.join(' ')} failed${signal ? ` (${signal})` : ''}`, code ?? 1));
+    });
+  });
+}
+
+async function writeGenerated(file, content, force) {
+  if (!force && await exists(file)) {
+    throw usageError(`refusing to overwrite ${file}`, 'Pass --force to regenerate.');
+  }
+  await fs.writeFile(file, content);
+  if (file.endsWith('copy-wasm.cjs')) {
+    await fs.chmod(file, 0o755);
+  }
+}
+
+async function readJsonIfExists(file) {
+  try {
+    const raw = await fs.readFile(file, 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+async function exists(file) {
+  try {
+    await fs.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function askText(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  const answer = await rl.question(`${question}${suffix}: `);
+  return answer.trim() || defaultValue || '';
+}
+
+async function askYesNo(rl, question, defaultValue) {
+  const suffix = defaultValue ? ' [Y/n]' : ' [y/N]';
+  const answer = (await rl.question(`${question}${suffix}: `)).trim().toLowerCase();
+  if (!answer) return defaultValue;
+  return ['y', 'yes', 'true', '1'].includes(answer);
+}
+
+function parseArgv(argv) {
+  const dashDash = argv.indexOf('--');
+  const ownArgs = dashDash === -1 ? argv : argv.slice(0, dashDash);
+  const passthrough = dashDash === -1 ? [] : argv.slice(dashDash + 1);
+  const positionals = [];
+  const flags = {};
+
+  for (let i = 0; i < ownArgs.length; i += 1) {
+    const arg = ownArgs[i];
+
+    if (arg === '-y') {
+      flags.yes = true;
+      continue;
+    }
+    if (arg === '-f') {
+      flags.force = true;
+      continue;
+    }
+    if (arg === '-h') {
+      flags.help = true;
+      continue;
+    }
+
+    if (arg.startsWith('--')) {
+      const raw = arg.slice(2);
+
+      if (raw.startsWith('no-')) {
+        flags[toCamel(raw.slice(3))] = false;
+        continue;
+      }
+
+      const eq = raw.indexOf('=');
+      if (eq !== -1) {
+        flags[toCamel(raw.slice(0, eq))] = raw.slice(eq + 1);
+        continue;
+      }
+
+      const name = toCamel(raw);
+      const next = ownArgs[i + 1];
+      if (next && !next.startsWith('-')) {
+        flags[name] = next;
+        i += 1;
+      } else {
+        flags[name] = true;
+      }
+      continue;
+    }
+
+    positionals.push(arg);
+  }
+
+  return {
+    command: positionals[0] || '',
+    args: positionals.slice(1),
+    flags,
+    passthrough
+  };
+}
+
+function toCamel(flag) {
+  return flag.replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
+}
+
+function normalizeRelativeDir(value) {
+  const clean = String(value || '').trim();
+  if (!clean) return '.';
+  if (path.isAbsolute(clean)) return toPosixPath(path.relative(process.cwd(), clean));
+  return toPosixPath(clean.replace(/^\.\//, ''));
+}
+
+function sanitizePackageBase(name) {
+  let base = String(name || '')
+    .replace(/^@[^/]+\//, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/_+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+
+  if (!base) base = 'spa';
+  return base.slice(0, 54).replace(/-$/g, '') || 'spa';
+}
+
+function sanitizePackageName(name) {
+  let out = sanitizePackageBase(name);
+  if (/^[0-9]/.test(out)) out = `spa-${out}`;
+  return out;
+}
+
+function normalizeVersion(version) {
+  const raw = String(version || '').replace(/^v/, '').trim();
+  return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(raw) ? raw : '0.0.1';
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function rustString(value) {
+  return JSON.stringify(String(value));
+}
+
+function ensureTrailingSlash(value) {
+  return value.endsWith('/') ? value : `${value}/`;
+}
+
+function toPosixPath(value) {
+  return String(value).replaceAll(path.sep, '/').replaceAll('\\\\', '/');
+}
+
+function usageError(message, hint) {
+  const err = new Error(message);
+  err.exitCode = 2;
+  err.hint = hint;
+  return err;
+}
+
+function commandError(message, exitCode) {
+  const err = new Error(message);
+  err.exitCode = exitCode;
+  return err;
+}
+
+function commandVersion(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    shell: process.platform === 'win32'
+  });
+
+  if (result.error || result.status !== 0) return { ok: false, version: '' };
+  return { ok: true, version: String(result.stdout || result.stderr).trim().split('\n')[0] };
+}
+
+// Exported for the tiny node:test smoke tests.
+export const internals = {
+  parseArgv,
+  sanitizePackageBase,
+  sanitizePackageName,
+  normalizeVersion,
+  inferBuildCommand,
+  hashDirectory,
+  renderMainRs,
+  renderAssetsRs,
+  renderYoloConfigRs
+};

package/templates/assets.rs.tmpl

@@ -0,0 +1,8 @@
+// Generated by fastly-spa-yolo. Hack responsibly.
+// This is the only Rust file with the generated #[folder = "..."] path.
+
+use rust_embed::Embed;
+
+#[derive(Embed)]
+#[folder = "__FASTLY_SPA_YOLO_EMBED_FOLDER__"]
+pub struct Asset;

package/templates/compute-main.rs

@@ -0,0 +1,196 @@
+// Generated by fastly-spa-yolo. Hack responsibly.
+// This file is intentionally boring. The entire SPA is embedded by rust-embed.
+
+mod assets;
+mod yolo_config;
+
+use assets::Asset;
+use fastly::http::{header, Method, StatusCode};
+use fastly::{Error, Request, Response};
+use mime_guess::from_path;
+use rust_embed::{EmbeddedFile, RustEmbed};
+
+#[fastly::main]
+fn main(req: Request) -> Result<Response, Error> {
+    let method = req.get_method().clone();
+
+    if method != Method::GET && method != Method::HEAD {
+        return Ok(Response::from_status(StatusCode::METHOD_NOT_ALLOWED)
+            .with_header(header::ALLOW, "GET, HEAD")
+            .with_body("method not allowed"));
+    }
+
+    if req.get_path() == "/__yolo" {
+        return Ok(yolo_response(&method));
+    }
+
+    let Some(path) = normalize_path(req.get_path()) else {
+        return Ok(Response::from_status(StatusCode::BAD_REQUEST).with_body("bad path"));
+    };
+
+    let Some((served_path, file)) = resolve_asset(&path) else {
+        return Ok(Response::from_status(StatusCode::NOT_FOUND).with_body("not found"));
+    };
+
+    Ok(asset_response(&method, &served_path, file))
+}
+
+fn asset_response(method: &Method, served_path: &str, file: EmbeddedFile) -> Response {
+    let content_len = file.data.len();
+    let content_type = content_type_for(served_path);
+    let cache_control = cache_control_for(served_path);
+    let etag = etag_for(served_path);
+
+    let mut resp = Response::from_status(StatusCode::OK)
+        .with_header(header::CONTENT_TYPE, content_type)
+        .with_header(header::CACHE_CONTROL, cache_control)
+        .with_header(header::CONTENT_LENGTH, content_len.to_string())
+        .with_header(header::ETAG, etag)
+        .with_header("X-Yolo-Build", build_id());
+
+    if method == &Method::GET {
+        resp = resp.with_body(file.data.into_owned());
+    }
+
+    resp
+}
+
+fn yolo_response(method: &Method) -> Response {
+    let body = format!(
+        "{{\"name\":\"{}\",\"build\":\"{}\",\"assets\":{},\"mode\":\"embedded-spa-yolo\"}}",
+        json_escape(app_name()),
+        json_escape(build_id()),
+        Asset::iter().count()
+    );
+
+    let mut resp = Response::from_status(StatusCode::OK)
+        .with_header(header::CONTENT_TYPE, "application/json; charset=utf-8")
+        .with_header(header::CACHE_CONTROL, "no-cache")
+        .with_header(header::CONTENT_LENGTH, body.len().to_string())
+        .with_header("X-Yolo-Build", build_id());
+
+    if method == &Method::GET {
+        resp = resp.with_body(body);
+    }
+
+    resp
+}
+
+fn normalize_path(raw: &str) -> Option<String> {
+    if raw.is_empty() || raw == "/" {
+        return Some("index.html".to_string());
+    }
+
+    if raw.contains('\\') {
+        return None;
+    }
+
+    let raw = raw.trim_start_matches('/');
+    let mut parts = Vec::new();
+
+    for part in raw.split('/') {
+        match part {
+            "" | "." => {}
+            ".." => return None,
+            other => parts.push(other),
+        }
+    }
+
+    if parts.is_empty() {
+        Some("index.html".to_string())
+    } else {
+        Some(parts.join("/"))
+    }
+}
+
+fn resolve_asset(path: &str) -> Option<(String, EmbeddedFile)> {
+    if let Some(file) = Asset::get(path) {
+        return Some((path.to_string(), file));
+    }
+
+    let dir_index = format!("{}/index.html", path.trim_end_matches('/'));
+    if let Some(file) = Asset::get(&dir_index) {
+        return Some((dir_index, file));
+    }
+
+    if yolo_config::SPA_FALLBACK && looks_like_spa_route(path) {
+        return Asset::get("index.html").map(|file| ("index.html".to_string(), file));
+    }
+
+    None
+}
+
+fn looks_like_spa_route(path: &str) -> bool {
+    path.rsplit('/')
+        .next()
+        .map(|last| !last.contains('.'))
+        .unwrap_or(true)
+}
+
+fn content_type_for(path: &str) -> String {
+    let mime = from_path(path).first_or_octet_stream();
+
+    match mime.essence_str() {
+        "text/html" => "text/html; charset=utf-8".to_string(),
+        "text/css" => "text/css; charset=utf-8".to_string(),
+        "text/javascript" | "application/javascript" => "application/javascript; charset=utf-8".to_string(),
+        "application/json" => "application/json; charset=utf-8".to_string(),
+        "image/svg+xml" => "image/svg+xml; charset=utf-8".to_string(),
+        other => other.to_string(),
+    }
+}
+
+fn cache_control_for(path: &str) -> &'static str {
+    if path == "index.html" || path.ends_with("/index.html") {
+        "no-cache"
+    } else if looks_hashed_asset(path) {
+        "public, max-age=31536000, immutable"
+    } else {
+        "public, max-age=60"
+    }
+}
+
+fn looks_hashed_asset(path: &str) -> bool {
+    let filename = path.rsplit('/').next().unwrap_or(path);
+    filename
+        .split('.')
+        .any(|part| part.len() >= 8 && part.chars().all(|ch| ch.is_ascii_hexdigit()))
+}
+
+fn etag_for(path: &str) -> String {
+    let safe_path: String = path
+        .chars()
+        .map(|ch| {
+            if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' || ch == '.' {
+                ch
+            } else {
+                '_'
+            }
+        })
+        .collect();
+
+    format!("\"yolo-{}-{}\"", build_id(), safe_path)
+}
+
+fn app_name() -> &'static str {
+    option_env!("FASTLY_SPA_YOLO_APP_NAME").unwrap_or("fastly-spa-yolo")
+}
+
+fn build_id() -> &'static str {
+    option_env!("FASTLY_SPA_YOLO_BUILD_ID").unwrap_or("dev")
+}
+
+fn json_escape(value: &str) -> String {
+    let mut out = String::new();
+    for ch in value.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            other => out.push(other),
+        }
+    }
+    out
+}

package/templates/yolo_config.rs.tmpl

@@ -0,0 +1,3 @@
+// Generated by fastly-spa-yolo. Hack responsibly.
+
+pub const SPA_FALLBACK: bool = __FASTLY_SPA_YOLO_SPA_FALLBACK__;