sproutboat 0.8.0 → 0.9.0

package/src/main.ts

@@ -1,11 +1,13 @@
 #!/usr/bin/env bun
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { basename, resolve } from "node:path";
+import { mkdir, open, readFile, rename, writeFile } from "node:fs/promises";
+import { rmSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
 import { isBoolean, isSafeInteger, isString, jsonObject, parseJsonValue, type JsonObject } from "./json";
 import type { AssetFiles } from "./assets";
 import { parseConfig, pinBindingId, resourceRefs, type SproutboatConfig } from "./config";
 import { validateHttpSyncSource } from "./source";
 import { buildArtifact } from "./build";
+import { generateTypes, TYPES_FILE } from "./types-gen";
 import { bundleHandler, BundleError, type BundleResult } from "./bundle";
 import { runDev } from "./dev";
 import { buildStandalone } from "./standalone-build";
@@ -231,6 +233,35 @@ async function check(directory?: string) {
   console.log(ok(`check passed — ${project.config.name} (${project.config.main}, native-fetch)`));
 }
 
+async function types(directory?: string) {
+  const project = await readProject(directory);
+  const path = resolve(project.directory, TYPES_FILE);
+  await writeFile(path, generateTypes(project.config));
+  console.log(ok(`wrote ${relative(process.cwd(), path) || TYPES_FILE}`));
+  console.log(dim("  Commit it. Add it to tsconfig `include` if your project has one."));
+}
+
+/**
+ * Rewrite the generated types when the config has moved on, and only then.
+ *
+ * Called from `dev` and `deploy` so a binding added to sproutboat.jsonc cannot
+ * sit unreflected in the editor. It writes only when the content actually
+ * differs, which keeps it out of the way of git and of file watchers.
+ */
+async function refreshTypes(projectDir: string, config: SproutboatConfig): Promise<void> {
+  const path = resolve(projectDir, TYPES_FILE);
+  const wanted = generateTypes(config);
+  try {
+    if ((await readFile(path, "utf8")) === wanted) return;
+  } catch {
+    // No file yet: only write one if the project already opted in by having a
+    // tsconfig. Generating into a plain JavaScript project is noise.
+    if (!(await Bun.file(resolve(projectDir, "tsconfig.json")).exists())) return;
+  }
+  await writeFile(path, wanted);
+  console.log(dim(`  ${TYPES_FILE} refreshed from sproutboat.jsonc`));
+}
+
 async function build(directory?: string, target: "linux-x86_64" | "host" = "linux-x86_64") {
   const project = await readProject(directory);
   console.log(
@@ -287,6 +318,7 @@ async function dev(args: string[]) {
   if (!Number.isSafeInteger(port) || port < 1 || port > 65_535)
     usageError(`invalid --port: ${portArg}`, "dev [project-dir] [--port <n>] [--no-watch]");
   const project = await readProject(directory);
+  await refreshTypes(project.directory, project.config);
   console.log(dim(`Building ${project.config.name} for this machine (${hostTarget()})…`));
   await runDev({
     projectDir: project.directory,
@@ -410,6 +442,8 @@ async function deploy(args: string[]) {
     projectName = built.project.config.name;
     artifactDir = built.artifact.artifactDir;
     config = built.project.config;
+    // After provisioning: ids may have been pinned into the config just now.
+    await refreshTypes(built.project.directory, built.project.config);
   }
   const manifest = Bun.file(resolve(artifactDir, "manifest.json"));
   const sprout = Bun.file(resolve(artifactDir, "sprout"));
@@ -897,6 +931,194 @@ async function storage(key: string, args: string[]) {
   console.log(ok(`deleted ${product.noun} ${name}`));
 }
 
+function option(args: string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+async function writeAtomic(
+  path: string,
+  chunks: AsyncIterable<string> | readonly string[],
+  overwrite: boolean,
+): Promise<void> {
+  const destination = resolve(path);
+  if (!overwrite && (await Bun.file(destination).exists())) fail(`${path} already exists; pass --force to replace it`);
+  await mkdir(dirname(destination), { recursive: true });
+  const temporary = `${destination}.tmp-${process.pid}-${Date.now()}`;
+  const cleanup = () => {
+    try {
+      rmSync(temporary, { force: true });
+    } catch {
+      /* best effort during process shutdown */
+    }
+  };
+  process.once("exit", cleanup);
+  const file = await open(temporary, "wx", 0o600);
+  try {
+    for await (const chunk of chunks) await file.write(chunk);
+    await file.sync();
+    await file.close();
+    await rename(temporary, destination);
+    process.off("exit", cleanup);
+  } catch (error) {
+    await file.close().catch(() => undefined);
+    cleanup();
+    process.off("exit", cleanup);
+    throw error;
+  }
+}
+
+async function kvContents(args: string[]): Promise<void> {
+  const area = args.shift();
+  if (!area || !["key", "bulk", "export"].includes(area))
+    usageError("kv: unknown contents command", "kv <key | bulk | export> ...");
+  const namespace = area === "export" ? args.shift() : args[1];
+  if (!namespace) usageError(`kv ${area}: missing <namespace>`, `kv ${area} <namespace> ...`);
+  const { apiUrl, token } = await apiCredentials();
+  const rows = await storageRows(`${apiUrl}/api/kv`, { "x-api-key": token }, STORAGE_PRODUCTS[0]);
+  const id = idForName(rows, namespace, STORAGE_PRODUCTS[0]);
+  const base = `${apiUrl}/api/kv/${id}`;
+  const auth = { "x-api-key": token };
+
+  if (area === "key") {
+    const verb = args.shift();
+    args.shift();
+    if (!verb || !["list", "get", "put", "delete"].includes(verb))
+      usageError("kv key: unknown operation", "kv key <list | get | put | delete> <namespace> ...");
+    if (verb === "list") {
+      const query = new URLSearchParams();
+      for (const flag of ["--prefix", "--cursor", "--limit"] as const) {
+        const value = option(args, flag);
+        if (value !== undefined) query.set(flag.slice(2), value);
+      }
+      const body = await responseText(await fetch(`${base}/keys?${query}`, { headers: auth }), "list rejected");
+      console.log(body);
+      return;
+    }
+    const key = args.shift();
+    if (!key) usageError(`kv key ${verb}: missing <key>`, `kv key ${verb} <namespace> <key>`);
+    const url = `${base}/keys/${encodeURIComponent(key)}`;
+    if (verb === "get") {
+      const body = await responseText(await fetch(url, { headers: auth }), "get rejected");
+      const record = jsonObject(parseJsonValue(body));
+      if (!record || !isString(record.value)) fail("get response did not contain a value");
+      const output = option(args, "--output");
+      if (output) await writeAtomic(output, [record.value], args.includes("--force"));
+      else console.log(args.includes("--text") ? record.value : JSON.stringify({ key, value: record.value }, null, 2));
+      return;
+    }
+    if (verb === "put") {
+      const path = option(args, "--path");
+      const positional = args.find((arg, index) => !arg.startsWith("-") && args[index - 1] !== "--path");
+      if (path && positional)
+        usageError(
+          "kv key put: use a value or --path, not both",
+          "kv key put <namespace> <key> [value] [--path <file>]",
+        );
+      const value = path ? await readFile(resolve(path), "utf8") : (positional ?? (await Bun.stdin.text()));
+      await responseText(
+        await fetch(url, {
+          method: "PUT",
+          headers: { ...auth, "content-type": "application/json" },
+          body: JSON.stringify({ value }),
+        }),
+        "put rejected",
+      );
+      console.log(ok(`set ${key}`));
+      return;
+    }
+    if (!args.includes("--yes")) fail(`this permanently deletes "${key}"; re-run with --yes`);
+    await responseText(await fetch(url, { method: "DELETE", headers: auth }), "delete rejected");
+    console.log(ok(`deleted ${key}`));
+    return;
+  }
+
+  if (area === "bulk") {
+    const verb = args.shift();
+    args.shift();
+    const input = args.shift();
+    if (!verb || !["get", "put", "delete"].includes(verb) || !input)
+      usageError(
+        "kv bulk: expected an operation, namespace, and JSON file",
+        "kv bulk <get | put | delete> <namespace> <file>",
+      );
+    if (verb === "delete" && !args.includes("--yes")) fail("bulk deletion requires --yes");
+    const parsed = parseJsonValue(await readFile(resolve(input), "utf8"));
+    if (!Array.isArray(parsed) || parsed.length === 0) fail("bulk input must be a non-empty JSON array");
+    const responses: unknown[] = [];
+    let changed = 0;
+    const failures: unknown[] = [];
+    for (let start = 0; start < parsed.length; start += 100) {
+      const body = await responseText(
+        await fetch(`${base}/bulk/${verb}`, {
+          method: "POST",
+          headers: { ...auth, "content-type": "application/json" },
+          body: JSON.stringify(parsed.slice(start, start + 100)),
+        }),
+        `bulk ${verb} rejected`,
+      );
+      const result = parseJsonValue(body);
+      if (verb === "get" && Array.isArray(result)) responses.push(...result);
+      else {
+        const summary = jsonObject(result);
+        changed += Number(summary?.written ?? summary?.deleted ?? 0);
+        if (Array.isArray(summary?.failures)) failures.push(...summary.failures);
+      }
+    }
+    const result = verb === "get" ? responses : { [verb === "put" ? "written" : "deleted"]: changed, failures };
+    const output = option(args, "--output");
+    if (output) await writeAtomic(output, [JSON.stringify(result, null, 2) + "\n"], args.includes("--force"));
+    else console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const output = option(args, "--output");
+  if (!output)
+    usageError(
+      "kv export: missing --output <file>",
+      "kv export <namespace> --output <dump.json> [--prefix <prefix>] [--force]",
+    );
+  const prefix = option(args, "--prefix") ?? "";
+  async function* dump(): AsyncGenerator<string> {
+    yield "[\n";
+    let cursor = "";
+    let first = true;
+    do {
+      const query = new URLSearchParams({ prefix, limit: "100" });
+      if (cursor) query.set("cursor", cursor);
+      const listed = jsonObject(
+        parseJsonValue(
+          await responseText(await fetch(`${base}/keys?${query}`, { headers: auth }), "export list rejected"),
+        ),
+      );
+      const keys = Array.isArray(listed?.keys) ? listed.keys.filter(isString) : [];
+      if (keys.length) {
+        const values = parseJsonValue(
+          await responseText(
+            await fetch(`${base}/bulk/get`, {
+              method: "POST",
+              headers: { ...auth, "content-type": "application/json" },
+              body: JSON.stringify(keys),
+            }),
+            "export read rejected",
+          ),
+        );
+        if (!Array.isArray(values)) fail("export response was not an array");
+        for (const entry of values) {
+          const record = jsonObject(entry);
+          if (!record || !isString(record.key) || !isString(record.value)) continue;
+          yield `${first ? "" : ",\n"}  ${JSON.stringify({ key: record.key, value: record.value })}`;
+          first = false;
+        }
+      }
+      cursor = isString(listed?.cursor) ? listed.cursor : "";
+    } while (cursor);
+    yield "\n]\n";
+  }
+  await writeAtomic(output, dump(), args.includes("--force"));
+  console.log(ok(`exported ${namespace} to ${output}`));
+}
+
 async function deleteProject(args: string[]) {
   // `sproutboat delete [project-dir] [--name <project>] --yes` — flags in any order.
   const positional: string[] = [];
@@ -963,6 +1185,9 @@ switch (command) {
   case "check":
     await check(args[0]);
     break;
+  case "types":
+    await types(args[0]);
+    break;
   case "dev":
     await dev(args);
     break;
@@ -998,6 +1223,9 @@ switch (command) {
     await secrets(args);
     break;
   case "kv":
+    if (["key", "bulk", "export"].includes(args[0] ?? "")) await kvContents(args);
+    else await storage(command, args);
+    break;
   case "d1":
   case "r2":
   case "queues":

package/src/native-fetch-prelude.js

@@ -587,8 +587,8 @@ globalThis.__sbInstallBindings = function (target, bindings) {
 
   // Static assets: env.<ASSETS>.fetch(request) -> broker `assets.get`. The edge
   // already serves matching files directly; the sprout only calls this for paths
-  // it wants to own (SPA fallback, auth-gated files). Text assets only — binary
-  // files go through the edge (the broker frame is UTF-8 JSON).
+  // it wants to own (SPA fallback, auth-gated files). The transport keeps the
+  // body byte-preserving for binary assets.
   if (bindings.assets) {
     target[bindings.assets] = {
       fetch(input) {
@@ -598,7 +598,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
         } catch {
           /* use as-is */
         }
-        const r = __sbRpc("assets.get", { path });
+        const r = globalThis.__sbAssetsGet(path);
         const headers = {};
         if (r.type) headers["content-type"] = r.type;
         if (r.found) headers["etag"] = '"' + r.hash + '"';

package/src/surface.ts

@@ -57,9 +57,9 @@ const storageCommands: readonly Command[] = STORAGE_PRODUCTS.map((product) => ({
   name: product.name,
   group: "Storage" as const,
   emoji: product.emoji,
-  args: STORAGE_ARGS,
+  args: product.name === "kv" ? `${STORAGE_ARGS} | <key | bulk | export> ...` : STORAGE_ARGS,
   brief: `<${STORAGE_VERBS.join(" | ")}>`,
-  summary: `${product.plural[0].toUpperCase()}${product.plural.slice(1)}. \`create\` prints the id to bind from sproutboat.jsonc${product.name === "queues" ? "; consumers deliver in batches with retries, and stop after 5 attempts" : ""}.`,
+  summary: `${product.plural[0].toUpperCase()}${product.plural.slice(1)}. \`create\` prints the id to bind from sproutboat.jsonc${product.name === "kv" ? "; key and bulk operations manage contents, and export writes a restorable JSON dump" : ""}${product.name === "queues" ? "; consumers deliver in batches with retries, and stop after 5 attempts" : ""}.`,
 }));
 
 export const COMMANDS: readonly Command[] = [
@@ -77,6 +77,14 @@ export const COMMANDS: readonly Command[] = [
     args: "[project-dir]",
     summary: "Validate the config and entry point without building.",
   },
+  {
+    name: "types",
+    group: "Develop",
+    emoji: "🧾",
+    args: "[project-dir]",
+    summary:
+      "Write sproutboat-env.d.ts from the config, so an editor knows what `env` holds. `dev` and `deploy` refresh it when the config is newer.",
+  },
   {
     name: "dev",
     group: "Develop",
@@ -189,8 +197,14 @@ export const ENV_VARS: readonly EnvVar[] = [
   {
     name: "SPROUTBOAT_UWS_TARBALL",
     purpose:
-      "Path to a prebuilt uWebSockets (x86_64-linux-musl) tarball to seed the Porffor cache with, instead of downloading it (removes the first-build git + make need).",
+      "Path to a uWebSockets source tarball to seed the Porffor cache with, instead of the one vendored in the package. Both targets are seeded from it.",
+  },
+  {
+    name: "CC",
+    purpose:
+      "C compiler used to build uSockets for a host build (default `cc`). A host build needs one regardless: it is what Porffor compiles its own generated C with.",
   },
+  { name: "AR", purpose: "Archiver used to assemble uSockets.a for a host build (default `ar`)." },
   { name: "SPROUTBOAT_COMPILE_TIMEOUT_MS", purpose: "Porffor compile timeout in ms (default 600000)." },
   {
     name: "SPROUTBOAT_VARS_JSON",

package/src/toolchain.ts

@@ -156,6 +156,11 @@ export async function ensureUWebSockets(): Promise<void> {
     }
   }
 
+  await extractUws(archive, dir);
+}
+
+/** Unpack the vendored source tree into `dir`. */
+async function extractUws(archive: string, dir: string): Promise<void> {
   await mkdir(dir, { recursive: true });
   const untar = Bun.spawn(["tar", "-xJf", archive, "-C", dir, "--strip-components=1"], {
     stdout: "pipe",
@@ -168,6 +173,72 @@ export async function ensureUWebSockets(): Promise<void> {
   }
 }
 
+/**
+ * The same seeding for a **host** build (`dev`, `build --target host`,
+ * `--standalone` on this machine).
+ *
+ * The vendored archive is a full checkout, so the sources are the same for
+ * every target; only `uSockets.a` is target-specific. Porffor would build that
+ * with `make -C uSockets`, which is where the `git` and `make` requirements on
+ * a first build came from. Compiling the thirteen C files directly removes
+ * both, and adds no new dependency: a host build already needs a C compiler,
+ * because that is what Porffor compiles its own generated C with.
+ *
+ * Flags mirror the uSockets makefile's default target with the WITH_* switches
+ * Porffor passes (all off): `-std=c11 -Isrc -DLIBUS_NO_SSL -flto -O3`, then
+ * `ar rvs`. Nothing here is a judgement call; it is that recipe.
+ */
+export async function ensureUWebSocketsHost(): Promise<void> {
+  const commit = uwsCommitFull();
+  const dir = resolve(homedir(), ".cache/porffor/deps", `uWebSockets-${commit}`);
+  const uSockets = resolve(dir, "uSockets");
+  const archivePath = resolve(uSockets, "uSockets.a");
+  if (existsSync(resolve(dir, "src/App.h")) && existsSync(archivePath)) return;
+
+  const vendored = process.env.SPROUTBOAT_UWS_TARBALL || uwsVendorArchive(commit.slice(0, 8));
+  if (!existsSync(vendored)) {
+    throw new UwsUnavailableError(`no vendored uWebSockets archive at ${vendored}`);
+  }
+  if (!process.env.SPROUTBOAT_UWS_TARBALL) {
+    const actual = await sha256File(vendored);
+    if (actual !== UWS_TARBALL_SHA256) {
+      throw new UwsUnavailableError(
+        `vendored uWebSockets sha256 mismatch\n  expected ${UWS_TARBALL_SHA256}\n  got      ${actual}`,
+      );
+    }
+  }
+  if (!existsSync(resolve(dir, "src/App.h"))) await extractUws(vendored, dir);
+
+  // The archive carries the musl-built uSockets.a. Linking that into a host
+  // binary fails in a way nobody would connect to this, so it goes first.
+  await rm(archivePath, { force: true });
+
+  const sources = ["src/*.c", "src/eventing/*.c", "src/crypto/*.c", "src/io_uring/*.c"];
+  const cc = process.env.CC || "cc";
+  const ar = process.env.AR || "ar";
+  const compile = Bun.spawn(["sh", "-c", `${cc} -std=c11 -Isrc -DLIBUS_NO_SSL -flto -O3 -c ${sources.join(" ")}`], {
+    cwd: uSockets,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [ccCode, ccErr] = await Promise.all([compile.exited, new Response(compile.stderr).text()]);
+  if (ccCode !== 0) {
+    throw new UwsUnavailableError(
+      `could not compile uSockets with ${cc}: ${ccErr.trim().split("\n").slice(-3).join(" ")}`,
+    );
+  }
+
+  const archiveStep = Bun.spawn(["sh", "-c", `${ar} rvs uSockets.a *.o`], {
+    cwd: uSockets,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [arCode, arErr] = await Promise.all([archiveStep.exited, new Response(archiveStep.stderr).text()]);
+  if (arCode !== 0 || !existsSync(archivePath)) {
+    throw new UwsUnavailableError(`could not archive uSockets with ${ar}: ${arErr.trim()}`);
+  }
+}
+
 /** Directory holding node_modules/porffor (walks up from this file). */
 export function porfforRoot(start = import.meta.dir): string {
   let dir = start;

package/src/transport-broker.js

@@ -288,3 +288,12 @@ globalThis.__sbR2Get = function (bucket, key) {
   if (!reply.found) return { found: false };
   return { found: true, object: reply.object, body: __sbTakeBin() };
 };
+
+/** Static asset metadata stays JSON; the response body uses the v1 byte tail. */
+globalThis.__sbAssetsGet = function (path) {
+  const token = __sbEnv("SB_BROKER_TOKEN");
+  const reply = JSON.parse(__sbCallBin(JSON.stringify({ v: 1, token, op: "assets.get", path }), ""));
+  if (reply.ok === false) throw new Error("sproutboat assets.get: " + (reply.error || "failed"));
+  reply.body = __sbTakeBin();
+  return reply;
+};

package/src/transport-embedded.js

@@ -1413,6 +1413,10 @@ globalThis.__sbR2Get = function (bucket, key) {
   return { found: true, object: meta.object, body: __sbR2GetRaw(__sbStore(), String(bucket), String(key)) };
 };
 
+globalThis.__sbAssetsGet = function (path) {
+  return __sbEmbeddedDispatch({ op: "assets.get", path });
+};
+
 /** The transport contract: one request string in, one reply string out. */
 function __sbCall(reqJson) {
   try {

package/src/types-gen.ts

@@ -0,0 +1,90 @@
+/**
+ * `sproutboat types` — the project's `env`, as TypeScript.
+ *
+ * In Workers `env` is a parameter, so an editor can infer it from a signature.
+ * Here it is a global, which means nothing is inferable at all: `env.SESSIONS`
+ * is an undeclared identifier until this file exists. That makes generated
+ * types worth more here than they are there, not less.
+ *
+ * The output declares `env` from `sproutboat.jsonc` and references the ambient
+ * types shipped in `types/sproutboat.d.ts`, so binding *shapes* version with
+ * the CLI and binding *names* version with the project.
+ *
+ * Names need no quoting: `parseConfig` already holds every binding and var to
+ * /^[A-Z][A-Z0-9_]*$/, so all of them are plain identifiers.
+ */
+import { resourceRefs, type SproutboatConfig } from "./config";
+
+/** The file the generator writes, relative to the project directory. */
+export const TYPES_FILE = "sproutboat-env.d.ts";
+
+const HEADER = `// Generated by \`sproutboat types\`. Do not edit.
+//
+// Regenerated whenever sproutboat.jsonc is newer than this file, so a binding
+// added to the config shows up in the editor without asking. Commit it: it is
+// part of the project's type surface, like a schema.
+`;
+
+type Entry = { name: string; type: string; note?: string };
+
+function entries(config: SproutboatConfig): Entry[] {
+  const out: Entry[] = [];
+
+  for (const [name, value] of Object.entries(config.vars ?? {})) {
+    out.push({ name, type: "string", note: `vars: ${JSON.stringify(value)}` });
+  }
+  for (const name of config.secrets ?? []) {
+    out.push({ name, type: "string", note: "secret, set with `sproutboat secrets set`" });
+  }
+  for (const { binding } of resourceRefs(config.kv_namespaces)) out.push({ name: binding, type: "KVNamespace" });
+  for (const { binding } of resourceRefs(config.d1_databases)) out.push({ name: binding, type: "D1Database" });
+  for (const { binding } of resourceRefs(config.r2_buckets)) out.push({ name: binding, type: "R2Bucket" });
+  for (const { binding } of resourceRefs(config.queues)) out.push({ name: binding, type: "Queue" });
+  for (const name of config.analytics_engine_datasets ?? []) {
+    out.push({ name, type: "AnalyticsEngineDataset" });
+  }
+  for (const [binding, className] of Object.entries(config.durable_objects ?? {})) {
+    out.push({ name: binding, type: "DurableObjectNamespace", note: `class ${className}` });
+  }
+  for (const service of config.services ?? []) {
+    out.push({ name: service.binding, type: "Fetcher", note: `service binding: ${service.service}` });
+  }
+  if (config.assets?.binding) {
+    out.push({ name: config.assets.binding, type: "Fetcher", note: `static assets: ${config.assets.directory}` });
+  }
+  return out;
+}
+
+/**
+ * The contents of `sproutboat-env.d.ts` for `config`.
+ *
+ * Pure, so the test can assert on the text and `dev` can compare it against
+ * what is already on disk without writing.
+ */
+export function generateTypes(config: SproutboatConfig): string {
+  const rows = entries(config);
+  const body = rows.length
+    ? rows
+        .map((entry) => `    ${entry.note ? `/** ${entry.note} */\n    ` : ""}${entry.name}: ${entry.type};`)
+        .join("\n")
+    : "    // No bindings declared in sproutboat.jsonc yet.";
+
+  return `${HEADER}
+/// <reference types="sproutboat/types" />
+
+declare global {
+  /**
+   * Bindings from sproutboat.jsonc, for project "${config.name}".
+   *
+   * A global, not a parameter: the handler signature is \`fetch(request)\`.
+   * Every call on these is synchronous, so \`await\` is allowed and does
+   * nothing.
+   */
+  const env: {
+${body}
+  };
+}
+
+export {};
+`;
+}