rastack 0.0.57 → 0.0.59

package/src/external/route.ts

@@ -0,0 +1,33 @@
+/**
+ * Parse the rastack REST path both the mini `rastack dev` service and the
+ * deployed Lambda receive into a {@link RastackRequest}. The contract is fixed:
+ *
+ *   /api/{app}/v1/{model}/            → list
+ *   /api/{app}/v1/{model}/{id}/       → detail
+ *
+ * Kept pure and separate from the servers so it is tested without a socket.
+ */
+
+import type { RastackRequest } from "./handler";
+
+/** Parse a request URL (path + optional query) into a rastack request, or null. */
+export function parseApiPath(url: string): RastackRequest | null {
+  const [rawPath, rawQuery = ""] = url.split("?");
+  const segments = rawPath.split("/").filter(Boolean); // api, {app}, v1, {model}, [id]
+  if (segments.length < 4 || segments[0] !== "api" || segments[2] !== "v1") {
+    return null;
+  }
+  const app = decodeURIComponent(segments[1]);
+  const model = decodeURIComponent(segments[3]);
+  const id = segments[4] ? decodeURIComponent(segments[4]) : undefined;
+
+  const query: Record<string, string[]> = {};
+  for (const pair of rawQuery.split("&")) {
+    if (!pair) continue;
+    const eq = pair.indexOf("=");
+    const key = decodeURIComponent(eq === -1 ? pair : pair.slice(0, eq));
+    const value = decodeURIComponent(eq === -1 ? "" : pair.slice(eq + 1)).replace(/\+/g, " ");
+    (query[key] ??= []).push(value);
+  }
+  return { app, model, id, query };
+}

package/src/external/service.ts

@@ -0,0 +1,86 @@
+/**
+ * The mini local proxy service — the "lambda you run while iterating".
+ *
+ * `rastack dev` already serves the app + admin over WASM for the stack's *own*
+ * resources. This adds the other half for **external** resources: a request
+ * handler it mounts under `/api/`, so `useData("github.repo")` works locally,
+ * cached, before any real Lambda is deployed. It is a thin adapter over the pure
+ * {@link handleExternalRequest} core — parse the path, resolve dev auth from env
+ * vars, run the handler, serialise JSON — reused verbatim by the deployed Lambda
+ * (which swaps the env-var auth for Secrets Manager and the Map cache for a
+ * shared store).
+ */
+
+import { memoryCache, type ProxyCache } from "./cache";
+import { handleExternalRequest, type HandlerDeps } from "./handler";
+import { parseApiPath } from "./route";
+import type { FetchLike, ResourceBinding, ResourceResolver } from "./types";
+
+export interface ExternalService {
+  /** True when the path is an `/api/{app}/v1/{model}/` route this service owns. */
+  handles(url: string): boolean;
+  /**
+   * Handle a request. Returns the HTTP status, JSON body string, and whether it
+   * was a cache hit (for a dev-log line). Returns `null` when the path isn't an
+   * API route, so the caller falls through to its other handlers.
+   */
+  serve(
+    url: string,
+  ): Promise<{ status: number; json: string; cached: boolean } | null>;
+}
+
+export interface ServiceOptions {
+  bindings: ResourceBinding[];
+  /** Injected fetch; defaults to the global `fetch` (Node 18+/browsers). */
+  fetch?: FetchLike;
+  cache?: ProxyCache;
+  now?: () => number;
+  /** Per-app upstream auth headers. In dev, typically read from `process.env`. */
+  authHeaders?: HandlerDeps["authHeaders"];
+  /** Named resolvers for `resolver`-transport bindings (e.g. an AWS resolver). */
+  resolvers?: Record<string, ResourceResolver>;
+}
+
+/**
+ * Read a dev token for an app from the environment, e.g. `GITHUB_TOKEN`,
+ * `EXPO_TOKEN`. Returns a Bearer header when present, else nothing (public
+ * endpoints still work; private ones 401 with a clear upstream message). This is
+ * the *only* place a raw token is read locally — production reads Secrets Manager
+ * in the Lambda instead, and no token is ever sent to the client.
+ */
+export function envAuthHeaders(
+  env: Record<string, string | undefined> = process.env,
+): NonNullable<HandlerDeps["authHeaders"]> {
+  return (app): Record<string, string> => {
+    const token = env[`${app.toUpperCase()}_TOKEN`];
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  };
+}
+
+/** Create the mini external-API service `rastack dev` mounts. */
+export function createExternalService(opts: ServiceOptions): ExternalService {
+  const deps: HandlerDeps = {
+    fetch: opts.fetch ?? ((globalThis as { fetch?: FetchLike }).fetch as FetchLike),
+    cache: opts.cache ?? memoryCache(),
+    now: opts.now ?? (() => Date.now()),
+    authHeaders: opts.authHeaders ?? envAuthHeaders(),
+    resolvers: opts.resolvers,
+  };
+  if (!deps.fetch) {
+    throw new Error("createExternalService needs a `fetch` (none on globalThis).");
+  }
+
+  return {
+    handles: (url) => parseApiPath(url) !== null,
+    async serve(url) {
+      const req = parseApiPath(url);
+      if (!req) return null;
+      const result = await handleExternalRequest(req, opts.bindings, deps);
+      return {
+        status: result.status,
+        json: JSON.stringify(result.body),
+        cached: result.cached,
+      };
+    },
+  };
+}

package/src/external/types.ts

@@ -0,0 +1,121 @@
+/**
+ * External-API bindings — how a rastack `app.model` is served from an upstream
+ * REST or GraphQL API.
+ *
+ * The stack's own resources are served by the Rust API / WASM engine over the
+ * `/api/{app}/v1/{model}/` contract. An **external** resource (a GitHub repo, an
+ * Expo project, an AWS stack) is served by the proxy instead: it speaks the same
+ * contract to the client, and translates each request into an upstream call,
+ * normalises the response into rastack's DRF-shaped envelope, and caches it.
+ *
+ * One {@link ResourceBinding} describes that translation for a single model. The
+ * proxy core ({@link ./handler}) is a pure function of a request + the bindings +
+ * an injected `fetch`/cache, so the *same* logic runs in the deployed Lambda and
+ * in the mini service inside `rastack dev`.
+ */
+
+/** A minimal `fetch` surface — the global `fetch` satisfies it; tests fake it. */
+export interface FetchResponse {
+  status: number;
+  headers: { get(name: string): string | null };
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+}
+export type FetchLike = (
+  url: string,
+  init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+  },
+) => Promise<FetchResponse>;
+
+/** Common binding fields, independent of transport. */
+interface BindingBase {
+  /** The rastack app namespace, e.g. `"github"`. */
+  app: string;
+  /** The rastack model, the `{model}` in `/api/{app}/v1/{model}/`. */
+  model: string;
+  /** The upstream field that is the row's identity. Default `"id"`. */
+  primaryKey?: string;
+  /** Cache TTL in ms for this resource's responses. Default 60_000. */
+  ttlMs?: number;
+  /** Whitelist of upstream fields to project into each row (default: all). */
+  fields?: string[];
+  /** Static headers merged into every upstream request (auth is separate). */
+  headers?: Record<string, string>;
+}
+
+/** Serve a model from an upstream REST endpoint. */
+export interface RestBinding extends BindingBase {
+  transport: "rest";
+  /** Upstream origin, e.g. `"https://api.github.com"`. */
+  baseUrl: string;
+  /** Path to the list, e.g. `"/user/repos"`. */
+  listPath: string;
+  /** Path to a detail; `{id}` is substituted, e.g. `"/repositories/{id}"`. */
+  detailPath?: string;
+  /**
+   * Map rastack list params (`page`, `page_size`, `search`, `order_by`) to the
+   * upstream's own names (`page`, `per_page`, `q`, `sort`). Unmapped params are
+   * dropped, so the upstream never sees rastack-only query keys.
+   */
+  queryMap?: Partial<Record<"page" | "page_size" | "search" | "order_by", string>>;
+  /** Dot path to the array inside the list response (default: the body *is* the array). */
+  itemsPath?: string;
+}
+
+/** Serve a model from an upstream GraphQL endpoint. */
+export interface GraphQLBinding extends BindingBase {
+  transport: "graphql";
+  /** The GraphQL endpoint URL, e.g. `"https://api.expo.dev/graphql"`. */
+  baseUrl: string;
+  /** The list query. Variables are filled from {@link variableMap}. */
+  listQuery: string;
+  /** Dot path into `data` to the array, e.g. `"me.accounts.0.apps"`. */
+  itemsPath: string;
+  /** Optional detail query; `$id` variable is bound to the requested id. */
+  detailQuery?: string;
+  /** Dot path into `data` to the detail object. */
+  detailPath?: string;
+  /** Map rastack params to GraphQL variable names (e.g. `page_size` → `first`). */
+  variableMap?: Partial<Record<"page" | "page_size" | "search" | "order_by" | "id", string>>;
+  /** Static variables merged into every query. */
+  variables?: Record<string, unknown>;
+}
+
+/**
+ * Serve a model from an injected resolver function rather than a plain HTTP
+ * call — for upstreams that need an SDK/signing the proxy core shouldn't import
+ * (AWS SigV4, say). The named resolver is provided via `HandlerDeps.resolvers`,
+ * so the framework stays dependency-free while the app plugs in, e.g., an AWS
+ * CloudFormation resolver. Still consumed through the normal `useData` contract.
+ */
+export interface ResolverBinding extends BindingBase {
+  transport: "resolver";
+  /** Key into `HandlerDeps.resolvers` for the function that produces the data. */
+  resolver: string;
+}
+
+export type ResourceBinding = RestBinding | GraphQLBinding | ResolverBinding;
+
+/**
+ * A resolver produces the upstream data for a {@link ResolverBinding}: an array
+ * for a list request, or a single object for a detail request. Normalisation
+ * into the rastack envelope is done by the core, exactly as for HTTP transports.
+ */
+export type ResourceResolver = (args: {
+  app: string;
+  model: string;
+  id?: string;
+  query: Record<string, string[]>;
+}) => Promise<unknown>;
+
+/** Look a binding up by `app`/`model`. */
+export function findBinding(
+  bindings: ResourceBinding[],
+  app: string,
+  model: string,
+): ResourceBinding | undefined {
+  return bindings.find((b) => b.app === app && b.model === model);
+}

package/src/external/util.ts

@@ -0,0 +1,57 @@
+/** Small pure helpers shared by the proxy core. */
+
+/**
+ * Read a value at a dot path (`"me.accounts.0.apps"`) out of a JSON value.
+ * Numeric segments index arrays. Returns `undefined` for any missing hop, so
+ * callers can default gracefully rather than throw on a shape they didn't get.
+ */
+export function getPath(value: unknown, path: string | undefined): unknown {
+  if (!path) return value;
+  let cur: unknown = value;
+  for (const segment of path.split(".")) {
+    if (cur == null) return undefined;
+    if (Array.isArray(cur)) {
+      const idx = Number(segment);
+      cur = Number.isInteger(idx) ? cur[idx] : undefined;
+    } else if (typeof cur === "object") {
+      cur = (cur as Record<string, unknown>)[segment];
+    } else {
+      return undefined;
+    }
+  }
+  return cur;
+}
+
+/** Keep only `fields` on a row (plus always its `id`). No-op when unset. */
+export function projectFields(
+  row: Record<string, unknown>,
+  fields: string[] | undefined,
+): Record<string, unknown> {
+  if (!fields || !fields.length) return row;
+  const out: Record<string, unknown> = {};
+  if ("id" in row) out.id = row.id;
+  for (const f of fields) if (f in row) out[f] = row[f];
+  return out;
+}
+
+/**
+ * Ensure a row carries an `id` (the rastack detail-URL key). If the upstream's
+ * identity lives under a different `primaryKey`, mirror it onto `id`.
+ */
+export function ensureId(
+  row: Record<string, unknown>,
+  primaryKey: string,
+): Record<string, unknown> {
+  if (primaryKey !== "id" && row.id === undefined && row[primaryKey] !== undefined) {
+    return { ...row, id: row[primaryKey] };
+  }
+  return row;
+}
+
+/** First value for a key in a parsed query (`{ page: ["2"] }` → `"2"`). */
+export function firstParam(
+  query: Record<string, string[]>,
+  key: string,
+): string | undefined {
+  return query[key]?.[0];
+}

package/src/rastack-dev.ts

@@ -21,9 +21,10 @@
  * but a Rust + wasm toolchain is, it is built from source as a fallback.
  */
 
-import { execFileSync, spawnSync } from "child_process";
+import { execFileSync, spawn, spawnSync, type ChildProcess } from "child_process";
 import * as fs from "fs";
 import * as http from "http";
+import * as net from "net";
 import * as path from "path";
 import { runCompile } from "./compile";
 import {
@@ -31,6 +32,7 @@ import {
   WASM_ENTRY,
   appRootCandidates,
   contentType,
+  type DevArgs,
   parseDevArgs,
   renderWelcome,
   wasmBundleCandidates,
@@ -128,8 +130,225 @@ function openBrowser(url: string): void {
   }
 }
 
-function main(argv: string[]): void {
+// ---------------------------------------------------------------------------
+// Live-dev mode — `rastack dev` for an Expo / react-native-web app.
+//
+// A React Native (Expo) app has no static `index.html`: its web build is a
+// Metro bundle. Rather than make the developer run a second tool, `dev` starts
+// Expo's Metro dev server itself and reverse-proxies to it, so `rastack dev`
+// stays the single command *and* keeps Metro's fast-refresh. The WASM
+// static-serve path remains the default for apps that ship a built index.html.
+// ---------------------------------------------------------------------------
+
+/** True when the project is an Expo app (so `dev` should drive Metro). */
+function isExpoProject(cwd: string): boolean {
+  try {
+    const appJson = JSON.parse(
+      fs.readFileSync(path.join(cwd, "app.json"), "utf-8"),
+    );
+    if (appJson && appJson.expo) return true;
+  } catch {
+    /* no app.json — fall through to package.json */
+  }
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(cwd, "package.json"), "utf-8"),
+    );
+    if (pkg?.dependencies?.expo || pkg?.devDependencies?.expo) return true;
+  } catch {
+    /* no package.json */
+  }
+  return false;
+}
+
+/** Locate the prebuilt wasm bundle without the cargo fallback (optional here). */
+function findWasmDir(): string | null {
+  for (const dir of wasmBundleCandidates(HERE)) {
+    if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
+  }
+  return null;
+}
+
+/** Grab an ephemeral free TCP port for Metro (avoids a fixed-port clash). */
+function getFreePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      const port = addr && typeof addr === "object" ? addr.port : 0;
+      srv.close(() => (port ? resolve(port) : reject(new Error("no free port"))));
+    });
+  });
+}
+
+/** Start `expo start --web` on `port`, with a reload-enabled environment. */
+function startMetro(cwd: string, port: number): ChildProcess {
+  // A live dev server needs watch mode, so we must NOT set CI (Expo reads it as
+  // "reloads disabled"). BROWSER=none stops Expo opening its own tab — we front
+  // it on the rastack port. `shell:true` keeps the npx / npx.cmd split portable.
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    BROWSER: "none",
+    EXPO_NO_TELEMETRY: "1",
+  };
+  delete env.CI;
+  // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+  const child = spawn(`npx expo start --web --port ${port}`, {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: true,
+  });
+  // Surface Metro's own errors (bundling failures, port issues) with a prefix.
+  child.stderr?.on("data", (d) => process.stderr.write(`  [metro] ${d}`));
+  return child;
+}
+
+/** Poll Metro's `/status` until it answers `packager-status:running`. */
+function waitForMetro(port: number, timeoutMs = 120_000): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve) => {
+    const retry = () =>
+      Date.now() > deadline ? resolve(false) : setTimeout(tick, 400);
+    const tick = () => {
+      const req = http.get(
+        { host: "127.0.0.1", port, path: "/status", timeout: 2000 },
+        (res) => {
+          let body = "";
+          res.on("data", (c) => (body += c));
+          res.on("end", () =>
+            body.includes("packager-status:running") ? resolve(true) : retry(),
+          );
+        },
+      );
+      req.on("error", retry);
+      req.on("timeout", () => req.destroy());
+    };
+    tick();
+  });
+}
+
+/** Reverse-proxy one HTTP request/response pair to Metro. */
+function proxyToMetro(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  port: number,
+): void {
+  const proxyReq = http.request(
+    { host: "127.0.0.1", port, method: req.method, path: req.url, headers: req.headers },
+    (proxyRes) => {
+      res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+      proxyRes.pipe(res);
+    },
+  );
+  proxyReq.on("error", () => {
+    if (!res.headersSent) res.writeHead(502);
+    res.end("Metro is not reachable.");
+  });
+  req.pipe(proxyReq);
+}
+
+/** Reverse-proxy a WebSocket upgrade (Metro HMR / fast-refresh) to Metro. */
+function proxyUpgrade(
+  req: http.IncomingMessage,
+  clientSocket: net.Socket,
+  head: Buffer,
+  port: number,
+): void {
+  const upstream = net.connect(port, "127.0.0.1", () => {
+    const lines = [`${req.method} ${req.url} HTTP/1.1`];
+    for (const [k, v] of Object.entries(req.headers)) {
+      if (Array.isArray(v)) v.forEach((vv) => lines.push(`${k}: ${vv}`));
+      else if (v != null) lines.push(`${k}: ${v}`);
+    }
+    upstream.write(lines.join("\r\n") + "\r\n\r\n");
+    if (head && head.length) upstream.write(head);
+    upstream.pipe(clientSocket);
+    clientSocket.pipe(upstream);
+  });
+  upstream.on("error", () => clientSocket.destroy());
+  clientSocket.on("error", () => upstream.destroy());
+}
+
+/** `rastack dev` for an Expo app: start Metro and reverse-proxy to it. */
+async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
+  // The wasm engine is optional here — an Expo/RN-web app runs its own engine —
+  // so a missing bundle is fine. When present, the reserved backend routes work.
+  const wasmDir = findWasmDir();
+
+  const metroPort = await getFreePort();
+  console.log(`▸ Starting Metro bundler (Expo) on :${metroPort} …`);
+  const metro = startMetro(cwd, metroPort);
+
+  let shuttingDown = false;
+  const stop = (code = 0) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    try {
+      metro.kill();
+    } catch {
+      /* already gone */
+    }
+    process.exit(code);
+  };
+  process.on("SIGINT", () => stop(0));
+  process.on("SIGTERM", () => stop(0));
+  metro.on("exit", (code) => {
+    if (!shuttingDown) {
+      console.error(`\n  ✗ Metro exited (code ${code ?? "?"}).`);
+      process.exit(code ?? 1);
+    }
+  });
+
+  if (!(await waitForMetro(metroPort))) {
+    console.error("  ✗ Metro did not come up in time.");
+    return stop(1);
+  }
+
+  const server = http.createServer((req, res) => {
+    const url = (req.url || "/").split("?")[0];
+    // Reserved backend routes win when the engine bundle is available.
+    if (wasmDir && url.startsWith("/wasm/"))
+      return serveUnder(res, wasmDir, url.slice("/wasm/".length));
+    if (url === "/schema.rastack.json" || url === "/openapi.json")
+      return serveUnder(res, args.outDir, path.basename(url));
+    if (url.startsWith("/data/warehouse/"))
+      return serveUnder(res, args.warehouseDir, url.slice("/data/warehouse/".length));
+    // Everything else → the live Metro bundle (HTML, JS, assets, HMR polls).
+    return proxyToMetro(req, res, metroPort);
+  });
+  server.on("upgrade", (req, socket, head) =>
+    proxyUpgrade(req, socket as net.Socket, head, metroPort),
+  );
+  server.on("error", (err: NodeJS.ErrnoException) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(
+        `\n  ✗ Port ${args.port} is already in use — is \`rastack dev\` already running?\n` +
+          `    Stop it, or pick another port: rastack dev --port <n>\n`,
+      );
+    } else {
+      console.error(`\n  ✗ dev server error: ${err.message}`);
+    }
+    stop(1);
+  });
+
+  server.listen(args.port, () => {
+    const url = `http://localhost:${args.port}`;
+    console.log(`  ✓ Metro live on :${metroPort} — fast refresh on`);
+    if (wasmDir)
+      console.log(`  ✓ WASM engine: ${path.relative(cwd, wasmDir)}`);
+    console.log(`\n  ▸ ${url}\n`);
+    console.log(
+      "  Edits reload live. Need the database console? Run `rastack admin`. Ctrl+C to stop.\n",
+    );
+    if (args.open) openBrowser(url);
+  });
+}
+
+async function main(argv: string[]): Promise<void> {
   const args = parseDevArgs(argv);
+  const cwd = process.cwd();
 
   console.log(`\n  rastack dev — your app, in your browser over WASM\n`);
   console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
@@ -138,6 +357,14 @@ function main(argv: string[]): void {
     process.exit(1);
   }
 
+  // Serve the developer's own app when there is one; otherwise the welcome page.
+  const appRoot = resolveAppRoot(args.appDir);
+
+  // No static build, but an Expo source tree → drive Metro live (fast refresh).
+  if (!appRoot && isExpoProject(cwd)) {
+    return runMetroMode(args, cwd);
+  }
+
   const wasmDir = resolveWasmDir();
   if (!wasmDir) {
     console.error(
@@ -150,9 +377,6 @@ function main(argv: string[]): void {
     process.exit(1);
   }
 
-  // Serve the developer's own app when there is one; otherwise the welcome page.
-  const appRoot = resolveAppRoot(args.appDir);
-
   const server = http.createServer((req, res) => {
     const url = (req.url || "/").split("?")[0];
     if (req.method !== "GET") {
@@ -212,5 +436,8 @@ function main(argv: string[]): void {
 }
 
 if (require.main === module) {
-  main(process.argv.slice(2));
+  main(process.argv.slice(2)).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
 }

package/src/rastack-wasm-build.ts

@@ -6,7 +6,7 @@
  *
  * Pipeline:
  *   1. cargo build -p rastack-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → tools/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
  * This is invoked by the release CI (to bundle a prebuilt engine into the npm
@@ -20,9 +20,9 @@ import { spawnSync } from "child_process";
 import fs from "fs";
 import path from "path";
 
-const repoRoot = path.resolve(__dirname, "..", "..");
-const rustDir = path.join(repoRoot, "rust");
-const outDir = path.join(repoRoot, "tools", "wasm");
+const repoRoot = path.resolve(__dirname, "..");
+const rustDir = path.join(repoRoot, "engine");
+const outDir = path.join(repoRoot, "wasm");
 const wasmPath = path.join(
   rustDir,
   "target",
@@ -78,7 +78,7 @@ export function buildWasm(): void {
     rustDir,
   );
 
-  console.log("→ wasm-bindgen → tools/wasm/");
+  console.log("→ wasm-bindgen → wasm/");
   run("wasm-bindgen", [
     "--target",
     "web",
@@ -105,7 +105,7 @@ export function buildWasm(): void {
   }
 
   const size = fs.statSync(path.join(outDir, "rastack_wasm_bg.wasm")).size;
-  console.log(`✓ wasm engine built: tools/wasm/ (${(size / 1024).toFixed(0)} KB)`);
+  console.log(`✓ wasm engine built: wasm/ (${(size / 1024).toFixed(0)} KB)`);
 }
 
 if (require.main === module) {

package/jest.config.cjs

@@ -1,12 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testMatch: ['**/test/**/*.spec.ts'],
-  moduleFileExtensions: ['ts', 'js'],
-  // Let executed test fixtures import the package by its published subpath
-  // names, the same way a consumer would (the resource compiler resolves these
-  // via its own ts.Program; these mappings are for code jest actually runs).
-  moduleNameMapper: {
-    '^rastack/tokens$': '<rootDir>/tokens.ts',
-  },
-};