appstage 0.2.1

package/dist/index.mjs

@@ -0,0 +1,622 @@
+import { access, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, extname, join, posix, relative, sep } from "node:path";
+import { formatDate, formatDuration } from "dateshape";
+import { randomBytes } from "node:crypto";
+import { STATUS_CODES } from "node:http";
+import { spawn } from "node:child_process";
+import esbuild from "esbuild";
+import EventEmitter from "node:events";
+import express from "express";
+
+function emitLog(app, message, payload) {
+  let normalizedPayload = {
+    timestamp: Date.now(),
+    ...payload,
+    ...typeof message === "string" || message instanceof Error ? { message } : message
+  };
+  return app.events?.emit("log", normalizedPayload);
+}
+
+function toLanguage(locale) {
+  return locale.split(/[-_]/)[0];
+}
+
+async function resolveFilePath({ name, dir = ".", lang, supportedLocales = [], ext, index }) {
+  let cwd = process.cwd();
+  let localeSet = new Set(supportedLocales);
+  let langSet = new Set(supportedLocales.map(toLanguage));
+  let availableNames = [name, ...[...localeSet, ...langSet].map((item) => `${name}.${item}`)];
+  let preferredLangNames;
+  if (lang && (!supportedLocales.length || localeSet.has(lang) || langSet.has(lang))) preferredLangNames = [`${name}.${lang}`, `${name}.${toLanguage(lang)}`];
+  let names = new Set(preferredLangNames ? [...preferredLangNames, ...availableNames] : availableNames);
+  let exts = Array.isArray(ext) ? ext : [ext];
+  for (let item of names) for (let itemExt of exts) {
+    let path = join(cwd, dir, `${item}${itemExt ? `.${itemExt}` : ""}`);
+    try {
+      await access(path);
+      return path;
+    } catch {}
+  }
+  if (index) for (let item of names) for (let itemExt of exts) {
+    let path = join(cwd, dir, item, `index${itemExt ? `.${itemExt}` : ""}`);
+    try {
+      await access(path);
+      return path;
+    } catch {}
+  }
+}
+
+const defaultExt = ["html", "htm"];
+const defaultName = (req) => req.path.split("/").at(-1);
+/**
+* Serves files from the specified directory path in a locale-aware
+* fashion after applying optional transforms.
+*
+* A file ending with `.<lang>.<ext>` is picked first if the `<lang>`
+* part matches `req.ctx.lang`. If the `supportedLocales` array is
+* provided, the `*.<lang>.<ext>` file is picked only if the given
+* array contains `req.ctx.lang`. Otherwise, a file without the locale
+* in its path (`*.<ext>`) is picked.
+*/
+const dir = ({ path, name = defaultName, ext = defaultExt, transform, supportedLocales, index = true }) => {
+  if (typeof path !== "string") throw new Error(`'path' is not a string`);
+  let transformSet = (Array.isArray(transform) ? transform : [transform]).filter((item) => typeof item === "function");
+  return async (req, res) => {
+    let fileName = typeof name === "function" ? name(req, res) : name;
+    emitLog(req.app, `Name: ${JSON.stringify(fileName)}`, {
+      req,
+      res
+    });
+    if (fileName === void 0) {
+      res.status(404).send(await req.app.renderStatus?.(req, res));
+      return;
+    }
+    let filePath = await resolveFilePath({
+      name: fileName,
+      dir: path,
+      ext,
+      supportedLocales,
+      lang: req.ctx?.lang,
+      index
+    });
+    emitLog(req.app, `Path: ${JSON.stringify(filePath)}`, {
+      req,
+      res
+    });
+    if (!filePath) {
+      res.status(404).send(await req.app.renderStatus?.(req, res));
+      return;
+    }
+    let content = (await readFile(filePath)).toString();
+    for (let transformItem of transformSet) content = await transformItem(req, res, {
+      content,
+      path: filePath,
+      name: basename(filePath, extname(filePath))
+    });
+    res.send(content);
+  };
+};
+
+const unhandledError = () => async (err, req, res) => {
+  emitLog(req.app, "Unhandled error", {
+    level: "error",
+    data: err,
+    req,
+    res
+  });
+  res.status(500).send(await req.app.renderStatus?.(req, res, "unhandled_error"));
+};
+
+const unhandledRoute = () => async (req, res) => {
+  emitLog(req.app, "Unhandled route", {
+    level: "debug",
+    req,
+    res
+  });
+  res.status(404).send(await req.app.renderStatus?.(req, res, "unhandled_route"));
+};
+
+function getEffectiveLocale(preferredLocales, supportedLocales) {
+  if (!supportedLocales || supportedLocales.length === 0) return void 0;
+  if (!preferredLocales || preferredLocales.length === 0) return supportedLocales[0];
+  let exactMatch = {};
+  for (let i = 0; i < preferredLocales.length && !exactMatch.locale; i++) {
+    let k = supportedLocales.indexOf(preferredLocales[i]);
+    if (k !== -1) {
+      exactMatch.index = i;
+      exactMatch.locale = supportedLocales[k];
+    }
+  }
+  let languageMatch = {};
+  let supportedLanguages = supportedLocales.map(toLanguage);
+  let preferredLanguages = preferredLocales.map(toLanguage);
+  for (let i = 0; i < preferredLanguages.length && !languageMatch.locale; i++) {
+    let k = supportedLanguages.indexOf(preferredLanguages[i]);
+    if (k !== -1) {
+      languageMatch.index = i;
+      languageMatch.locale = supportedLocales[k];
+    }
+  }
+  if (exactMatch.locale && (!languageMatch.locale || exactMatch.index < languageMatch.index)) return exactMatch.locale;
+  return languageMatch.locale ?? supportedLocales[0];
+}
+
+/**
+* Parses a language range string (typically a value of the 'Accept-Language'
+* HTTP request header) and returns a corresponding array of locales
+* @example 'fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5'
+*/
+function getLocales(languageRange) {
+  return (languageRange ?? "").split(/[,;]\s*/).filter((s) => !s.startsWith("q=") && s !== "*");
+}
+
+const ansiEscapeCodes = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m"
+};
+
+const levelColors = {
+  error: "red",
+  warn: "yellow"
+};
+
+function isEmpty(x) {
+  if (x === null || x === void 0 || x === "") return true;
+  if (Array.isArray(x) && x.length === 0) return true;
+  if (typeof x === "object" && Object.keys(x).length === 0) return true;
+  return false;
+}
+function log(message = "", { timestamp, level, data, req } = {}) {
+  let currentTime = timestamp ?? Date.now();
+  let error = null;
+  if (message instanceof Error) {
+    error = message;
+    message = error.message;
+    data = {
+      error,
+      data
+    };
+    if (!level) level = "error";
+  }
+  if (data instanceof Error) {
+    error = data;
+    if (data.message) message = `${message ? `${message} - ` : ""}${data.message}`;
+    if (!level) level = "error";
+  }
+  if (!level) level = "info";
+  let levelCode = ansiEscapeCodes[levelColors[level]] ?? "";
+  let requestTarget = req ? `${req.method} ${req.originalUrl}` : "";
+  let { startTime, id: sessionId } = req?.ctx ?? {};
+  console[level]();
+  console[level](levelCode + ansiEscapeCodes.dim + formatDate(currentTime, "{isoDate} {isoTimeMs} {tz}") + (sessionId ? ` <${sessionId}>` : "") + (startTime === void 0 ? "" : ` +${formatDuration(currentTime - startTime)}`) + ansiEscapeCodes.reset);
+  console[level](levelCode + requestTarget + (requestTarget && message && !message.startsWith("\n") ? " - " : "") + message + ansiEscapeCodes.reset);
+  if (!isEmpty(data)) console[level](levelCode + ansiEscapeCodes.dim + (typeof data === "string" ? data : JSON.stringify(data, null, 2)) + ansiEscapeCodes.reset);
+  if (error?.stack) console[level](levelCode + ansiEscapeCodes.dim + error.stack + ansiEscapeCodes.reset);
+}
+
+/**
+* Initializes the request context on `req.ctx`.
+*/
+const init = () => (req, res, next) => {
+  req.ctx = {
+    ...req.ctx,
+    id: randomBytes(16).toString("hex"),
+    nonce: randomBytes(8).toString("hex"),
+    startTime: Date.now()
+  };
+  emitLog(req.app, "Inited", {
+    req,
+    res
+  });
+  next();
+};
+
+const defaultLangCookieOptions = { maxAge: 90 * 864e5 };
+const lang = ({ supportedLocales = [], shouldSetCookie = true, shouldRedirect = true, langCookieOptions = defaultLangCookieOptions } = {}) => {
+  let langSet = new Set(supportedLocales.map(toLanguage));
+  let localeSet = new Set(supportedLocales);
+  return (req, res, next) => {
+    let langParam = req.query.lang;
+    let lang = (Array.isArray(langParam) ? langParam[0] : langParam) ?? "";
+    if (localeSet.has(lang) || langSet.has(lang)) {
+      if (shouldSetCookie) {
+        emitLog(req.app, `Set lang cookie: ${JSON.stringify(lang)}`, {
+          req,
+          res
+        });
+        res.cookie("lang", lang, langCookieOptions);
+      }
+      if (shouldRedirect) {
+        let { originalUrl } = req;
+        let nextUrl = originalUrl.replace(/[?&]lang=[^&]+/g, "");
+        if (nextUrl !== originalUrl) {
+          emitLog(req.app, "Strip lang param and redirect", {
+            req,
+            res
+          });
+          res.redirect(nextUrl);
+          return;
+        }
+      }
+    }
+    let langCookie = shouldSetCookie ? req.cookies.lang : void 0;
+    let userAgentLocales = getLocales(req.get("accept-language"));
+    let effectiveLang = getEffectiveLocale(langCookie ? [langCookie, ...userAgentLocales] : userAgentLocales, supportedLocales);
+    if (req.ctx && effectiveLang) req.ctx.lang = effectiveLang;
+    emitLog(req.app, `Detected lang: ${JSON.stringify(effectiveLang)}`, {
+      req,
+      res,
+      data: {
+        userAgentLocales,
+        langCookie,
+        lang: effectiveLang
+      }
+    });
+    next();
+  };
+};
+
+function getStatusMessage(prefix, statusCode) {
+  return `${prefix} - [${statusCode}] ${STATUS_CODES[statusCode]}`;
+}
+
+/**
+* Adds event handlers, like logging, to essential request phases.
+*/
+const requestEvents = () => (req, res, next) => {
+  let finished = false;
+  res.on("finish", () => {
+    finished = true;
+    emitLog(req.app, getStatusMessage("Finished", res.statusCode), {
+      req,
+      res
+    });
+  });
+  res.on("close", () => {
+    if (!finished) emitLog(req.app, getStatusMessage("Closed", res.statusCode), {
+      req,
+      res
+    });
+  });
+  next();
+};
+
+const commonBuildOptions = {
+  format: "cjs",
+  jsx: "automatic",
+  jsxDev: process.env.NODE_ENV === "development",
+  loader: {
+    ".png": "dataurl",
+    ".svg": "dataurl",
+    ".html": "text",
+    ".txt": "text"
+  }
+};
+
+async function getEntries() {
+  let cwd = process.cwd();
+  try {
+    let list = await readdir(join(cwd, "src/entries"));
+    return (await Promise.all(list.map(async (name) => {
+      return (await lstat(join(cwd, "src/entries", name))).isDirectory() ? name : void 0;
+    }))).filter((dir) => dir !== void 0);
+  } catch {
+    return [];
+  }
+}
+
+const entryExtensions = [
+  "js",
+  "jsx",
+  "ts",
+  "tsx"
+];
+
+async function getFirstAvailable(dirPath, path) {
+  let paths = Array.isArray(path) ? path : [path];
+  for (let filePath of paths) for (let ext of entryExtensions) {
+    let path = join(process.cwd(), dirPath, `${filePath}.${ext}`);
+    try {
+      await access(path);
+      return path;
+    } catch {}
+  }
+}
+
+async function getEntryPoints(path) {
+  let entries = await getEntries();
+  return (await Promise.all(entries.map(async (name) => {
+    let resolvedPath = await getFirstAvailable(`src/entries/${name}`, path);
+    return resolvedPath === void 0 ? void 0 : {
+      name,
+      path: resolvedPath
+    };
+  }))).filter((item) => item !== void 0);
+}
+
+/**
+* Builds the client-side code from the 'src/entries/<entry_name>/ui'
+* directories. The directories should preferrably be called 'ui' rather
+* than client since their contents can also be used with the server-side
+* rendering.
+*/
+async function buildClient({ publicAssetsDir, watch, watchClient }, plugins) {
+  let clientEntries = await getEntryPoints(["ui/index"]);
+  let buildOptions = {
+    ...commonBuildOptions,
+    entryPoints: clientEntries.map(({ path }) => path),
+    bundle: true,
+    splitting: true,
+    format: "esm",
+    outdir: `${publicAssetsDir}/-`,
+    outbase: "src/entries",
+    minify: process.env.NODE_ENV !== "development",
+    plugins
+  };
+  if (watch || watchClient) {
+    let ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+    return async () => {
+      await ctx.dispose();
+    };
+  }
+  await esbuild.build(buildOptions);
+}
+
+function toImportPath(relativePath, referencePath = ".") {
+  let cwd = process.cwd();
+  let importPath = posix.join(...relative(join(cwd, referencePath), relativePath).split(sep));
+  if (importPath && !/^\.+\//.test(importPath)) importPath = `./${importPath}`;
+  return importPath;
+}
+
+async function populateEntries() {
+  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let content = "";
+  if (serverEntries.length === 0) content = "export const entries = [];";
+  else {
+    content = "export const entries = (\n  await Promise.all([";
+    for (let i = 0; i < serverEntries.length; i++) content += `\n    // ${serverEntries[i].name}
+    import("${toImportPath(serverEntries[i].path, "src/server")}"),`;
+    content += "\n  ])\n).map(({ server }) => server);";
+  }
+  await writeFile("src/server/entries.ts", `// Populated automatically during the build phase by picking
+// all server exports from 'src/entries/<entry_name>/server(/index)?.(js|ts)'
+${content}
+`);
+}
+
+async function buildServer({ targetDir, watch, watchServer }, plugins) {
+  await populateEntries();
+  let buildOptions = {
+    ...commonBuildOptions,
+    entryPoints: ["src/server/index.ts"],
+    bundle: true,
+    splitting: true,
+    outdir: `${targetDir}/server`,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins
+  };
+  if (watch || watchServer) {
+    let ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+    return async () => {
+      await ctx.dispose();
+    };
+  }
+  await esbuild.build(buildOptions);
+}
+
+async function buildServerCSS({ targetDir, watch, watchServer }, plugins) {
+  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let buildOptions = {
+    ...commonBuildOptions,
+    entryPoints: serverEntries.map(({ name, path }) => ({
+      in: path,
+      out: name
+    })),
+    bundle: true,
+    splitting: false,
+    outdir: `${targetDir}/server-css`,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins
+  };
+  if (watch || watchServer) {
+    let ctx = await esbuild.context(buildOptions);
+    await ctx.watch();
+    return async () => {
+      await ctx.dispose();
+    };
+  }
+  await esbuild.build(buildOptions);
+}
+
+function createPostbuildPlugins({ targetDir, publicAssetsDir }, onServerRebuild) {
+  return {
+    serverPlugins: [{
+      name: "skip-css",
+      setup(build) {
+        /** @see https://github.com/evanw/esbuild/issues/599#issuecomment-745118158 */
+        build.onLoad({ filter: /\.css$/ }, () => ({ contents: "" }));
+      }
+    }, {
+      name: "postbuild-server",
+      setup(build) {
+        build.onEnd(() => {
+          onServerRebuild();
+        });
+      }
+    }],
+    serverCSSPlugins: [{
+      name: "postbuild-server-css",
+      setup(build) {
+        build.onEnd(async () => {
+          let dir = `${targetDir}/server-css`;
+          try {
+            let files = (await readdir(dir)).filter((name) => name.endsWith(".css"));
+            if (files.length === 0) return;
+            await mkdir(`${publicAssetsDir}/-`, { recursive: true });
+            await Promise.all(files.map(async (name) => {
+              let dir = `${publicAssetsDir}/-/${name.slice(0, -4)}`;
+              await mkdir(dir, { recursive: true });
+              await rename(`${targetDir}/server-css/${name}`, `${dir}/index.css`);
+            }));
+            await rm(dir, {
+              recursive: true,
+              force: true
+            });
+          } catch {}
+        });
+      }
+    }]
+  };
+}
+
+async function build(params) {
+  let startTime = Date.now();
+  let log = params.silent ? () => {} : console.log;
+  log("Build started");
+  let serverProcess = null;
+  let inited = false;
+  function handleServerRebuild() {
+    if (serverProcess) {
+      serverProcess.kill();
+      serverProcess = null;
+    }
+    if (!inited) {
+      log(`Build completed +${formatDuration(Date.now() - startTime)}`);
+      inited = true;
+    }
+    if (params.start) serverProcess = spawn("node", [`${params.targetDir}/server/index.js`], { stdio: "inherit" });
+  }
+  let { serverPlugins, serverCSSPlugins } = createPostbuildPlugins(params, handleServerRebuild);
+  await Promise.all([
+    buildServer(params, serverPlugins),
+    buildServerCSS(params, serverCSSPlugins),
+    buildClient(params)
+  ]);
+}
+
+const defaultTargetDir = "dist";
+async function clean({ targetDir, publicAssetsDir }) {
+  let dirs = [
+    `${targetDir}/server`,
+    `${targetDir}/server-css`,
+    `${publicAssetsDir}/-`
+  ];
+  return Promise.all(dirs.map((dir) => rm(dir, {
+    recursive: true,
+    force: true
+  })));
+}
+async function cli(args = []) {
+  let publicAssetsDir = args[0];
+  let targetDir = args[1];
+  if (!publicAssetsDir || publicAssetsDir.startsWith("--")) throw new Error("Public assets directory is undefined");
+  if (!targetDir || targetDir.startsWith("--")) targetDir = defaultTargetDir;
+  let params = {
+    targetDir,
+    publicAssetsDir,
+    silent: args.includes("--silent"),
+    watch: args.includes("--watch"),
+    watchServer: args.includes("--watch-server"),
+    watchClient: args.includes("--watch-client"),
+    start: args.includes("--start")
+  };
+  if (args.includes("--clean-only")) {
+    await clean(params);
+    return;
+  }
+  if (args.includes("--clean")) await clean(params);
+  await build(params);
+}
+
+async function start(nodeEnv = "development", host) {
+  if (nodeEnv) process.env.NODE_ENV = nodeEnv;
+  if (host) {
+    let [hostname, port] = host.split(":");
+    if (hostname) process.env.APP_HOST = hostname;
+    if (port) process.env.APP_PORT = port;
+  }
+  await cli(nodeEnv === "development" ? [
+    "src/public",
+    "--clean",
+    "--start",
+    "--watch"
+  ] : [
+    "src/public",
+    "--clean",
+    "--start",
+    "--silent"
+  ]);
+}
+
+const renderStatus = async (req, res) => {
+  let { id, nonce } = req.ctx;
+  let statusText = `${res.statusCode} ${STATUS_CODES[res.statusCode]}`;
+  let date = `${(/* @__PURE__ */ new Date()).toISOString().replace(/T/, " ").replace(/Z$/, "")} UTC`;
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"/><meta name="viewport" content="width=device-width"/><title>${statusText}</title><style${nonce ? ` nonce="${nonce}"` : ""}>body{text-align:center;}</style></head><body><h1>${statusText}</h1><hr/><p>` + (id ? `<code>ID: ${id}</code><br/>` : "") + `<code>${date}</code></p></body></html>`;
+};
+
+function createApp(callback) {
+  let app = express();
+  if (!app.events) app.events = new EventEmitter();
+  let host = process.env.APP_HOST || "localhost";
+  let port = Number(process.env.APP_PORT) || 80;
+  let listen = () => {
+    app.listen(port, host, () => {
+      emitLog(app, `Server running at ${`http://${host}:${port}/`} (${`NODE_ENV=${process.env.NODE_ENV}`})`);
+    });
+  };
+  if (process.env.NODE_ENV === "development") app.events?.on("log", ({ message, ...payload }) => {
+    log(message, payload);
+  });
+  if (!app.renderStatus) app.renderStatus = renderStatus;
+  app.disable("x-powered-by");
+  app.use(init());
+  app.use(requestEvents());
+  let callbackResult = typeof callback === "function" ? callback() : null;
+  if (callbackResult instanceof Promise) callbackResult.then(listen);
+  else listen();
+  return app;
+}
+
+const cspNonce = (req) => {
+  return `'nonce-${req.ctx?.nonce}'`;
+};
+
+const injectNonce = (req, _res, { content }) => {
+  let { nonce } = req.ctx;
+  return nonce ? content.replace(/\{\{nonce\}\}/g, nonce) : content;
+};
+
+function serializeState(state) {
+  return JSON.stringify(state).replace(/</g, "\\x3c");
+}
+
+function servePipeableStream(req, res) {
+  return async ({ pipe }, error) => {
+    let statusCode = error ? 500 : 200;
+    emitLog(req.app, getStatusMessage("Stream", statusCode), {
+      level: error ? "error" : void 0,
+      req,
+      res,
+      data: error
+    });
+    res.status(statusCode);
+    if (statusCode >= 400) {
+      res.send(await req.app.renderStatus?.(req, res));
+      return;
+    }
+    res.set("Content-Type", "text/html");
+    pipe(res);
+  };
+}
+
+export { build, cli, createApp, cspNonce, dir, emitLog, getEffectiveLocale, getLocales, getStatusMessage, init, injectNonce, lang, log, renderStatus, requestEvents, resolveFilePath, serializeState, servePipeableStream, start, toLanguage, unhandledError, unhandledRoute };

package/index.ts

@@ -0,0 +1,32 @@
+export * from "./src/controllers/dir.ts";
+export * from "./src/controllers/unhandledError.ts";
+export * from "./src/controllers/unhandledRoute.ts";
+export * from "./src/lib/lang/getEffectiveLocale.ts";
+export * from "./src/lib/lang/getLocales.ts";
+export * from "./src/lib/lang/toLanguage.ts";
+export * from "./src/lib/logger/LogOptions.ts";
+export * from "./src/lib/logger/log.ts";
+export * from "./src/middleware/init.ts";
+export * from "./src/middleware/lang.ts";
+export * from "./src/middleware/requestEvents.ts";
+export * from "./src/scripts/build.ts";
+export * from "./src/scripts/cli.ts";
+export * from "./src/scripts/start.ts";
+export * from "./src/types/Controller.ts";
+export * from "./src/types/ErrorController.ts";
+export * from "./src/types/LogEventPayload.ts";
+export * from "./src/types/LogLevel.ts";
+export * from "./src/types/Middleware.ts";
+export * from "./src/types/MiddlewareSet.ts";
+export * from "./src/types/RenderStatus.ts";
+export * from "./src/types/ReqCtx.ts";
+export * from "./src/types/TransformContent.ts";
+export * from "./src/utils/createApp.ts";
+export * from "./src/utils/cspNonce.ts";
+export * from "./src/utils/emitLog.ts";
+export * from "./src/utils/getStatusMessage.ts";
+export * from "./src/utils/injectNonce.ts";
+export * from "./src/utils/renderStatus.ts";
+export * from "./src/utils/resolveFilePath.ts";
+export * from "./src/utils/serializeState.ts";
+export * from "./src/utils/servePipeableStream.ts";

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "appstage",
+  "version": "0.2.1",
+  "description": "",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "appstage-build": "./dist/bin/build.js",
+    "appstage-dev": "./dist/bin/startDev.js",
+    "appstage-prod": "./dist/bin/startProd.js"
+  },
+  "scripts": {
+    "compile-build": "esbuild src/scripts/bin/build.ts --bundle --outfile=dist/bin/build.js --platform=node --external:esbuild --format=esm",
+    "compile-start-dev": "esbuild src/scripts/bin/startDev.ts --bundle --outfile=dist/bin/startDev.js --platform=node --external:esbuild --format=esm",
+    "compile-start-prod": "esbuild src/scripts/bin/startProd.ts --bundle --outfile=dist/bin/startProd.js --platform=node --external:esbuild --format=esm",
+    "preversion": "npx npm-run-all shape -p compile-build compile-start-dev compile-start-prod",
+    "shape": "npx codeshape",
+    "typecheck": "npx codeshape --typecheck-only"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/axtk/appstage.git"
+  },
+  "author": "axtk",
+  "license": "MIT",
+  "peerDependencies": {
+    "express": ">=5"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.4.0"
+  },
+  "dependencies": {
+    "dateshape": "^1.1.2",
+    "esbuild": "^0.27.3"
+  }
+}