@stacksjs/actions 0.70.160 → 0.70.161

package/README.md

@@ -9,7 +9,7 @@ This package contains the Stacks Actions.
 - Generate Stacks Library Entry Points
 - Generate Package Manifests
 - Generate VS Code Custom Data file
-- Generate Vue 2 Compatibility (maybe deprecate)
+- Generate STX component metadata
 
 ## 🤖 Usage
 

package/dist/build/desktop.js

@@ -1,5 +1,35 @@
-import { runCommand } from "@stacksjs/cli";
-import { corePath } from "@stacksjs/path";
-await runCommand("bun run build:app", {
-  cwd: corePath("desktop")
+import { chmodSync, copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import process from "node:process";
+import { log, runCommand } from "@stacksjs/cli";
+import { corePath, projectPath, storagePath } from "@stacksjs/path";
+import { resolveCraftBinary } from "@stacksjs/desktop";
+const outputDir = storagePath("framework/desktop-dist"), launcherName = process.platform === "win32" ? "stacks-desktop.exe" : "stacks-desktop", runtimeName = process.platform === "win32" ? "craft-runtime.exe" : "craft-runtime", appUrl = process.env.DESKTOP_URL || process.env.APP_URL;
+if (!appUrl)
+  throw Error("Desktop builds require APP_URL or DESKTOP_URL so the native app knows which Stacks application to open");
+const url = new URL(/^https?:\/\//.test(appUrl) ? appUrl : `https://${appUrl}`), craftBinary = resolveCraftBinary();
+if (basename(craftBinary) === "craft" && !existsSync(craftBinary))
+  throw Error("Build Craft first in ~/Code/Tools/craft, or set CRAFT_BIN to the native Craft binary");
+if (existsSync(outputDir))
+  rmSync(outputDir, { recursive: !0 });
+mkdirSync(outputDir, { recursive: !0 });
+await runCommand("bun run build", { cwd: corePath("desktop") });
+await runCommand(`bun build --compile ${JSON.stringify(corePath("desktop/src/launcher.ts"))} --outfile ${JSON.stringify(join(outputDir, launcherName))}`, {
+  cwd: projectPath()
 });
+copyFileSync(craftBinary, join(outputDir, runtimeName));
+if (process.platform !== "win32") {
+  chmodSync(join(outputDir, launcherName), 493);
+  chmodSync(join(outputDir, runtimeName), 493);
+}
+writeFileSync(join(outputDir, "desktop.json"), `${JSON.stringify({
+  url: url.toString().replace(/\/$/, ""),
+  title: process.env.APP_NAME || "Stacks",
+  width: 1400,
+  height: 900,
+  darkMode: !1,
+  systemTray: !0,
+  hideDockIcon: !1
+}, null, 2)}
+`);
+log.success(`Built Craft desktop application in ${outputDir}`);

package/dist/build/views.js

@@ -1,11 +1,16 @@
 import { runCommand } from "@stacksjs/cli";
-import { frameworkPath, projectPath } from "@stacksjs/path";
+import { projectPath } from "@stacksjs/path";
 const projectBuild = projectPath("build.ts");
-if (await Bun.file(projectBuild).exists())
-  await runCommand("bun build.ts", {
+if (await Bun.file(projectBuild).exists()) {
+  const result = await runCommand("bun build.ts", {
     cwd: projectPath()
   });
-else
-  await runCommand("bun run build", {
-    cwd: frameworkPath("views/web")
+  if (result.isErr)
+    throw result.error;
+} else {
+  const result = await runCommand("bunx --bun @stacksjs/stx build --pages resources/views --out dist", {
+    cwd: projectPath()
   });
+  if (result.isErr)
+    throw result.error;
+}

package/dist/copy-types.js

@@ -1,7 +1,6 @@
 import { frameworkPath } from "@stacksjs/path";
 import { copyFolder } from "@stacksjs/storage";
 const destinations = [
-  [frameworkPath("dist/types/components"), frameworkPath("defaults/resources/components/vue/dist/types")],
   [frameworkPath("dist/types/components"), frameworkPath("defaults/resources/components/web/dist/types")],
   [frameworkPath("dist/types/functions"), frameworkPath("defaults/functions/dist/types")]
 ];

package/dist/dev/components.js

@@ -3,5 +3,5 @@ import { libsPath } from "@stacksjs/path";
 const options = parseOptions();
 await runCommand("bun run dev", {
   ...options,
-  cwd: libsPath("components/vue")
+  cwd: libsPath("components/stx")
 });

package/dist/dev/dashboard.js

@@ -316,14 +316,14 @@ const dashboardToggles = await loadDashboardToggles(), manifestPath = storagePat
 writeFileSync(manifestPath, JSON.stringify(manifestPayload, null, 2));
 const serverReady = await waitForServer(dashboardPort);
 restoreConsole();
-let proxyStarted = !1;
-startReverseProxy().then((ok) => {
-  proxyStarted = ok;
-}).catch((err) => {
-  if (verbose)
-    console.warn("[Dashboard] Reverse proxy failed:", err);
-});
-const dashboardHttpsUrl = dashboardDomain ? `https://${dashboardDomain}` : null, dashboardLocalUrl = `http://localhost:${dashboardPort}`, initialUrl = `http://localhost:${dashboardPort}/`, elapsedMs = (Bun.nanoseconds() - startTime) / 1e6;
+let proxyStarted = Boolean(process.env.STACKS_PROXY_MANAGED);
+if (!proxyStarted)
+  proxyStarted = await startReverseProxy().catch((err) => {
+    if (verbose)
+      console.warn("[Dashboard] Reverse proxy failed:", err);
+    return !1;
+  });
+const dashboardHttpsUrl = dashboardDomain ? `https://${dashboardDomain}` : null, dashboardLocalUrl = `http://localhost:${dashboardPort}`, initialUrl = dashboardHttpsUrl && proxyStarted ? `${dashboardHttpsUrl}/` : `${dashboardLocalUrl}/`, elapsedMs = (Bun.nanoseconds() - startTime) / 1e6;
 console.log();
 console.log(`  ${bold(cyan("stacks dashboard"))}`);
 console.log();

package/dist/dev/desktop.d.ts

@@ -1 +1 @@
-export {};
+

package/dist/dev/desktop.js

@@ -1,5 +1 @@
-import { runCommand } from "@stacksjs/cli";
-import { frameworkPath } from "@stacksjs/path";
-await runCommand("bun run dev", {
-  cwd: frameworkPath("views/desktop")
-});
+await import("./dashboard");

package/dist/dev/system-tray.js

@@ -1,5 +1,172 @@
-import { runCommand } from "@stacksjs/cli";
-import { frameworkPath } from "@stacksjs/path";
-await runCommand("bun run dev", {
-  cwd: frameworkPath("system-tray")
+import { homedir, networkInterfaces } from "node:os";
+import { basename, join } from "node:path";
+import process from "node:process";
+import { bold, cyan, dim, green } from "@stacksjs/cli";
+import { openDevWindow } from "@stacksjs/desktop";
+import { projectPath, storagePath } from "@stacksjs/path";
+import { findStacksProjects } from "@stacksjs/utils";
+import { findAvailablePort, waitForServer } from "./dashboard-utils";
+const preferredPort = Number(process.env.PORT_SYSTEM_TRAY) || 3009, port = await findAvailablePort(preferredPort), trayViews = storagePath("framework/defaults/views/system-tray"), appUrl = process.env.APP_URL || "stacks.test", domain = appUrl.replace(/^https?:\/\//, "").replace(/\/$/, ""), hasPrettyDomain = !domain.includes("localhost:") && domain !== "localhost", trayDomain = hasPrettyDomain ? `tray.${domain}` : null, localUrl = `http://localhost:${port}`;
+let cachedProjects;
+async function discoverProjects(refresh = !1) {
+  if (cachedProjects && !refresh)
+    return cachedProjects;
+  const discovered = await findStacksProjects(join(homedir(), "Code"), { quiet: !0 }).catch(() => []), candidates = [...new Set([projectPath(), ...discovered])];
+  cachedProjects = (await Promise.all(candidates.map(async (project) => ({
+    project,
+    valid: await Bun.file(join(project, "buddy")).exists()
+  })))).filter((check) => check.valid).map((check) => check.project).sort((a, b) => basename(a).localeCompare(basename(b)));
+  return cachedProjects;
+}
+async function runBuddy(project, args) {
+  const child = Bun.spawn([join(project, "buddy"), ...args, "--no-interaction"], {
+    cwd: project,
+    stdout: "pipe",
+    stderr: "pipe"
+  }), [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  return { output: [stdout, stderr].filter(Boolean).join(`
+`).trim(), exitCode };
+}
+function openPath(path) {
+  const command = process.platform === "darwin" ? ["open", path] : process.platform === "win32" ? ["cmd", "/c", "start", "", path] : ["xdg-open", path];
+  Bun.spawn(command, { stdout: "ignore", stderr: "ignore" }).unref();
+}
+function openTerminal(project) {
+  const command = process.platform === "darwin" ? ["open", "-a", "Terminal", project] : process.platform === "win32" ? ["cmd", "/c", "start", "cmd", "/K", `cd /d ${project}`] : ["x-terminal-emulator", "--working-directory", project];
+  Bun.spawn(command, { stdout: "ignore", stderr: "ignore" }).unref();
+}
+function localIpAddress() {
+  for (const addresses of Object.values(networkInterfaces()))
+    for (const address of addresses || [])
+      if (address.family === "IPv4" && !address.internal)
+        return address.address;
+  return "127.0.0.1";
+}
+function dashboardUrl(path = "") {
+  return `${hasPrettyDomain ? `https://dashboard.${domain}` : `http://localhost:${Number(process.env.PORT_ADMIN) || 3002}`}${path}`;
+}
+async function handleAction(input) {
+  const projects = await discoverProjects(), project = input.project || projectPath();
+  if (!projects.includes(project))
+    return Response.json({ ok: !1, error: "Unknown Stacks project" }, { status: 400 });
+  switch (input.action) {
+    case "refresh":
+      return Response.json({ ok: !0, projects: await discoverProjects(!0) });
+    case "open-terminal":
+      openTerminal(project);
+      return Response.json({ ok: !0, message: `Opened Terminal in ${basename(project)}` });
+    case "env-check": {
+      const result = await runBuddy(project, ["doctor"]);
+      return Response.json({ ok: result.exitCode === 0, ...result });
+    }
+    case "settings":
+      openPath(dashboardUrl("/settings"));
+      return Response.json({ ok: !0, message: "Opened dashboard settings" });
+    case "check-updates": {
+      const result = await runBuddy(project, ["outdated"]);
+      return Response.json({ ok: result.exitCode === 0, ...result });
+    }
+    case "copy-ip":
+      return Response.json({ ok: !0, value: localIpAddress(), message: "IP address ready to copy" });
+    case "open-dashboard":
+      openPath(dashboardUrl());
+      return Response.json({ ok: !0, message: "Opened dashboard" });
+    case "buddy-commands": {
+      const result = await runBuddy(project, ["list"]);
+      return Response.json({ ok: result.exitCode === 0, ...result });
+    }
+    case "deploy": {
+      if (!input.confirmed)
+        return Response.json({ ok: !1, confirmationRequired: !0, error: "Deployment confirmation required" }, { status: 409 });
+      Bun.spawn([join(project, "buddy"), "deploy", "--no-interaction"], {
+        cwd: project,
+        stdout: "inherit",
+        stderr: "inherit"
+      }).unref();
+      return Response.json({ ok: !0, message: `Deployment started for ${basename(project)}` });
+    }
+    case "deploy-logs":
+      openPath(join(project, "storage/logs"));
+      return Response.json({ ok: !0, message: "Opened deployment logs" });
+    case "site-logs":
+      openPath(join(project, "storage/logs"));
+      return Response.json({ ok: !0, message: "Opened site logs" });
+    case "error-logs":
+      openPath(join(project, "storage/logs"));
+      return Response.json({ ok: !0, message: "Opened error logs" });
+    case "edit-env":
+      openPath(join(project, ".env"));
+      return Response.json({ ok: !0, message: "Opened .env" });
+    case "edit-dns":
+      openPath(join(project, "config/dns.ts"));
+      return Response.json({ ok: !0, message: "Opened DNS configuration" });
+    case "edit-email":
+      openPath(join(project, "config/email.ts"));
+      return Response.json({ ok: !0, message: "Opened email configuration" });
+    case "ask-buddy":
+      openPath(dashboardUrl("/buddy"));
+      return Response.json({ ok: !0, message: "Opened Ask Buddy" });
+    default:
+      return Response.json({ ok: !1, error: "Unknown tray action" }, { status: 400 });
+  }
+}
+const { serve } = await import("bun-plugin-stx/serve"), serverPromise = serve({
+  patterns: [trayViews],
+  port,
+  componentsDir: storagePath("framework/defaults/resources/components"),
+  quiet: !0,
+  auth: !1,
+  routes: {
+    "/api/tray/projects": async () => Response.json({ ok: !0, projects: await discoverProjects() }),
+    "/api/tray/action": async (request) => {
+      if (request.method !== "POST")
+        return Response.json({ ok: !1, error: "Method not allowed" }, { status: 405 });
+      return handleAction(await request.json());
+    }
+  }
 });
+serverPromise.catch((error) => {
+  console.error(`System tray server failed: ${error.message}`);
+  process.exit(1);
+});
+let proxyStarted = !1;
+if (trayDomain && !process.env.STACKS_PROXY_MANAGED)
+  try {
+    const { startProxies } = await import("@stacksjs/rpx");
+    await startProxies({
+      proxies: [{ from: `localhost:${port}`, to: trayDomain, cleanUrls: !1 }],
+      https: { basePath: `${process.env.HOME}/.stacks/ssl`, validityDays: 825 },
+      regenerateUntrustedCerts: !1
+    });
+    proxyStarted = !0;
+  } catch {
+    proxyStarted = !1;
+  }
+await waitForServer(port, 2000);
+const url = trayDomain && proxyStarted ? `https://${trayDomain}` : localUrl;
+console.log();
+console.log(`  ${bold(cyan("stacks tray"))}`);
+console.log();
+console.log(`  ${green("\u279C")}  ${bold("Local")}:   ${cyan(url)}`);
+if (trayDomain)
+  console.log(`  ${dim("\u279C")}  ${dim("Origin")}:  ${dim(localUrl)}`);
+console.log();
+await openDevWindow(port, {
+  url,
+  title: "Stacks",
+  width: 440,
+  height: 680,
+  systemTray: !0,
+  hideDockIcon: !0,
+  hotReload: !0
+});
+const stop = () => {
+  process.exit(0);
+};
+process.on("SIGINT", stop);
+process.on("SIGTERM", stop);
+await new Promise(() => {});

package/dist/examples.js

@@ -5,7 +5,7 @@ import { hasComponents } from "@stacksjs/storage";
 import { ExitCode } from "@stacksjs/types";
 import { runNpmScript } from "@stacksjs/utils";
 export async function invoke(options) {
-  if (options.components || options.vue)
+  if (options.components)
     await componentExample(options);
   else if (options.webComponents || options.elements)
     await webComponentExample(options);
@@ -17,7 +17,7 @@ export async function examples(options) {
 }
 export async function componentExample(options) {
   if (hasComponents()) {
-    await runNpmScript(NpmScript.ExampleVue, options);
+    await runNpmScript(NpmScript.Example, options);
     log.success("Your component library was built successfully");
   } else
     log.info("No components found.");

package/dist/helpers/lib-entries.js

@@ -53,18 +53,18 @@ export function generateEntryPointData(type) {
 `);
   }
   arr = determineResetPreset();
-  const imports = [...arr, "import { defineCustomElement } from 'vue'"], declarations = [], definitions = [];
+  const imports = [...arr, "import { defineCustomElement } from '@stacksjs/stx'"], declarations = [], definitions = [];
   if (!library.webComponents?.tags) {
     log.error(Error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments"));
     process.exit(ExitCode.FatalError);
   }
   for (const component of library.webComponents.tags.map((tag) => tag.name))
     if (Array.isArray(component)) {
-      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.vue'`);
+      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.stx'`);
       declarations.push(`const ${component[1]}CustomElement = defineCustomElement(${component[1]})`);
       definitions.push(`customElements.define('${kebabCase(component[1])}', ${component[1]}CustomElement)`);
     } else {
-      imports.push(`import ${component} from '${componentsPath(component)}.vue'`);
+      imports.push(`import ${component} from '${componentsPath(component)}.stx'`);
       declarations.push(`const ${component}CustomElement = defineCustomElement(${component})`);
       definitions.push(`customElements.define('${kebabCase(component)}', ${component}CustomElement)`);
     }

package/dist/helpers/vscode-custom-data.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@stacksjs/error-handling';
 export declare function generateVsCodeCustomData(): Promise<Result<void, string>>;
 export declare function generateWebTypes(): Promise<void>;
+export declare function generateWebTypesData(): string;

package/dist/helpers/vscode-custom-data.js

@@ -1,7 +1,7 @@
 import { library } from "@stacksjs/config";
 import { err, ok } from "@stacksjs/error-handling";
 import { log } from "@stacksjs/logging";
-import { customElementsDataPath } from "@stacksjs/path";
+import { customElementsDataPath, frameworkPath } from "@stacksjs/path";
 import { writeTextFile } from "@stacksjs/storage";
 function generateComponentInfoData() {
   return `{
@@ -26,5 +26,35 @@ export async function generateVsCodeCustomData() {
 }
 export async function generateWebTypes() {
   log.info("Generating web-types.json...");
-  log.info("This feature is not yet implemented.");
+  await writeTextFile({
+    path: frameworkPath("core/web-types.json"),
+    data: generateWebTypesData()
+  });
+  log.success("Generated web-types.json for IDEs.");
+}
+export function generateWebTypesData() {
+  const tags = (library.webComponents?.tags ?? []).map((tag) => {
+    const sourceName = Array.isArray(tag.name) ? tag.name[0] : tag.name;
+    return {
+      name: Array.isArray(tag.name) ? tag.name[1] : tag.name,
+      description: tag.description ?? "",
+      attributes: tag.attributes ?? [],
+      source: {
+        module: `../../defaults/resources/components/${sourceName}.stx`,
+        symbol: "default"
+      }
+    };
+  });
+  return `${JSON.stringify({
+    framework: "stx",
+    name: library.name,
+    contributions: {
+      html: {
+        "description-markup": "markdown",
+        "types-syntax": "typescript",
+        tags
+      }
+    }
+  }, null, 2)}
+`;
 }

package/dist/make.d.ts

@@ -13,6 +13,7 @@ export declare function makeAction(options: MakeOptions): Promise<void>;
 export declare function makeComponent(options: MakeOptions): Promise<void>;
 export declare function createAction(options: MakeOptions): Promise<void>;
 export declare function createComponent(options: MakeOptions): Promise<void>;
+export declare function componentFileName(name: string): string;
 export declare function makeDatabase(options: MakeOptions): void;
 export declare function createDatabase(options: MakeOptions): void;
 export declare function factory(options: MakeOptions): Promise<void>;
@@ -39,6 +40,7 @@ export declare function createMail(options: MakeOptions & { force?: boolean }):
 export declare function makeMail(options: MakeOptions & { force?: boolean }): Promise<void>;
 export declare function makePage(options: MakeOptions): Promise<void>;
 export declare function createPage(options: MakeOptions): Promise<void>;
+export declare function pageFileName(name: string): string;
 export declare function makeFunction(options: MakeOptions): Promise<void>;
 export declare function createFunction(options: MakeOptions): Promise<void>;
 export declare function makeLanguage(options: MakeOptions): Promise<void>;

package/dist/make.js

@@ -87,7 +87,10 @@ export async function createAction(options) {
 }
 export async function createComponent(options) {
   const name = options.name;
-  await createFileWithTemplate(p.userComponentsPath(`${name}.vue`), "component", name);
+  await createFileWithTemplate(p.userComponentsPath(componentFileName(name)), "component", name);
+}
+export function componentFileName(name) {
+  return `${name}.stx`;
 }
 export function makeDatabase(options) {
   try {
@@ -211,7 +214,10 @@ export async function makePage(options) {
 }
 export async function createPage(options) {
   const name = options.name;
-  await createFileWithTemplate(p.userViewsPath(`${name}.vue`), "page", name);
+  await createFileWithTemplate(p.userViewsPath(pageFileName(name)), "page", name);
+}
+export function pageFileName(name) {
+  return `${name}.stx`;
 }
 export async function makeFunction(options) {
   try {

package/dist/upgrade/packages.d.ts

@@ -1,3 +1,5 @@
+export declare function hasStacksDependency(pkg: PkgJson): boolean;
+export declare function standalonePackageUpdateCommand(): string;
 /**
  * Upgrade a node_modules app to a published framework version. Called by the
  * framework upgrade script when no vendored `storage/framework/core` exists.
@@ -12,3 +14,8 @@ export declare interface PackageUpgradeOptions {
   dryRun?: boolean
   noPostinstall?: boolean
 }
+declare interface PkgJson {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  [key: string]: unknown
+}

package/dist/upgrade/packages.js

@@ -2,6 +2,34 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import process from "node:process";
 import { runCommand } from "@stacksjs/cli";
+export function hasStacksDependency(pkg) {
+  return Boolean(pkg.dependencies?.stacks || pkg.devDependencies?.stacks);
+}
+export function standalonePackageUpdateCommand() {
+  return "bun update";
+}
+async function updateStandalonePackage(projectRoot, options) {
+  console.log(`
+  Standalone package detected. No Stacks framework source is installed.`);
+  if (options.dryRun) {
+    console.log("  --dry-run: would refresh the package dependencies with `bun update`. No files were changed.\n");
+    process.exit(0);
+  }
+  if (options.noPostinstall) {
+    console.log("  --no-postinstall: skipping the dependency refresh. Run `bun update` when ready.\n");
+    process.exit(0);
+  }
+  console.log(`  Refreshing declared dependencies...
+`);
+  if ((await runCommand(standalonePackageUpdateCommand(), { cwd: projectRoot })).isErr) {
+    console.error("\n\u2717 The dependency refresh failed. Resolve the reported error and re-run `buddy update`.\n");
+    process.exit(1);
+  }
+  console.log(`
+\u2714 Standalone package dependencies are up to date.
+`);
+  process.exit(0);
+}
 async function resolveTarget(options) {
   const res = await fetch("https://registry.npmjs.org/stacks").catch(() => null);
   if (!res || !res.ok)
@@ -45,7 +73,10 @@ export async function upgradeStacksPackages(projectRoot, options) {
     console.error("No package.json found \u2014 nothing to upgrade.");
     process.exit(1);
   }
-  const raw = readFileSync(pkgPath, "utf-8"), pkg = JSON.parse(raw), current = pkg.dependencies?.stacks ?? pkg.devDependencies?.stacks, { version: target, coreDeps } = await resolveTarget(options).catch((err) => {
+  const raw = readFileSync(pkgPath, "utf-8"), pkg = JSON.parse(raw), current = pkg.dependencies?.stacks ?? pkg.devDependencies?.stacks;
+  if (!hasStacksDependency(pkg))
+    return updateStandalonePackage(projectRoot, options);
+  const { version: target, coreDeps } = await resolveTarget(options).catch((err) => {
     console.error(`\u2717 ${err.message}`);
     process.exit(1);
   });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/actions",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.160",
+  "version": "0.70.161",
   "description": "The Stacks actions.",
   "author": "Chris Breuer",
   "contributors": [
@@ -62,31 +62,31 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/config": "0.70.160",
+    "@stacksjs/config": "0.70.161",
     "@stacksjs/bumpx": "^0.2.6",
-    "@stacksjs/bunpress": "^0.1.14",
+    "@stacksjs/bunpress": "^0.1.18",
     "@stacksjs/logsmith": "^0.2.3",
     "@stacksjs/ts-cloud": "^0.7.49",
     "@stacksjs/ts-md": "^0.1.1"
   },
   "devDependencies": {
-    "@stacksjs/api": "0.70.160",
-    "@stacksjs/cli": "0.70.160",
-    "@stacksjs/config": "0.70.160",
-    "@stacksjs/database": "0.70.160",
+    "@stacksjs/api": "0.70.161",
+    "@stacksjs/cli": "0.70.161",
+    "@stacksjs/config": "0.70.161",
+    "@stacksjs/database": "0.70.161",
     "@stacksjs/tlsx": "^0.13.2",
     "better-dx": "^0.2.17",
-    "@stacksjs/dns": "0.70.160",
-    "@stacksjs/enums": "0.70.160",
-    "@stacksjs/env": "0.70.160",
-    "@stacksjs/error-handling": "0.70.160",
-    "@stacksjs/logging": "0.70.160",
-    "@stacksjs/path": "0.70.160",
-    "@stacksjs/security": "0.70.160",
-    "@stacksjs/storage": "0.70.160",
-    "@stacksjs/strings": "0.70.160",
-    "@stacksjs/utils": "0.70.160",
-    "@stacksjs/validation": "0.70.160"
+    "@stacksjs/dns": "0.70.161",
+    "@stacksjs/enums": "0.70.161",
+    "@stacksjs/env": "0.70.161",
+    "@stacksjs/error-handling": "0.70.161",
+    "@stacksjs/logging": "0.70.161",
+    "@stacksjs/path": "0.70.161",
+    "@stacksjs/security": "0.70.161",
+    "@stacksjs/storage": "0.70.161",
+    "@stacksjs/strings": "0.70.161",
+    "@stacksjs/utils": "0.70.161",
+    "@stacksjs/validation": "0.70.161"
   },
   "peerDependencies": {
     "pickier": "^0.1.35"