@stacksjs/buddy 0.70.256 → 0.70.258

package/dist/commands/deploy.d.ts

@@ -43,6 +43,74 @@ export declare function resolveDeployEnvValues(environment: 'production' | 'stag
  * the process env).
  */
 export declare function mergeSiteDeployEnv(sites: Record<string, any>, resolvedDeployEnv: Record<string, string>): Record<string, any>;
+/**
+ * The SQLite file a site will open, relative to its release root — or `null`
+ * when the site is not on SQLite, or its database already lives outside the
+ * release tree (an absolute `DB_DATABASE_PATH` is the operator saying "I have
+ * placed this somewhere persistent myself").
+ *
+ * Mirrors config/database.ts' resolution order. `DB_DATABASE` is only a path
+ * when it looks like one — for every other driver it is a database NAME, and
+ * linking `stacks` as a file would be nonsense.
+ */
+export declare function siteSqlitePath(siteEnv?: Record<string, any>): string | null;
+/**
+ * Does the loaded ts-cloud actually keep persistent state the way
+ * {@link applyPersistentStatePaths} assumes?
+ *
+ * Declaring shared paths against a ts-cloud that lacks these is worse than not
+ * declaring them at all — it is the difference between "the database dies with
+ * its release" and "the deploy places an empty database over the live one and
+ * migrates into it". So this probes the two capabilities the declaration
+ * depends on and lets the caller refuse the deploy.
+ *
+ * Probed by generating a script and reading what it DOES, not by a version
+ * number or an exported symbol name: a version range goes stale the moment
+ * someone installs a fork, and an internal helper can be renamed without
+ * changing behaviour.
+ *
+ * @param buildSiteDeployScript ts-cloud's script builder, as loaded at runtime.
+ */
+export declare function tsCloudPersistentStateSupport(buildSiteDeployScript: unknown): { ok: boolean, missing: string[] };
+/**
+ * Where a project's app database lives on the box: one directory per project,
+ * outside every site's release tree.
+ *
+ * Deliberately derived from the project slug ALONE. ts-cloud installs each site
+ * under `/var/www/<slug>-<site>`, so anything derived from the site name gives
+ * each site a database of its own — which is exactly how `main` and `api` ended
+ * up on separate files, with only `main` ever migrated. Two sites of one project
+ * cannot disagree about a path that does not mention which site is asking.
+ */
+export declare function projectDatabaseTarget(slug: string, relativePath: string): string;
+/**
+ * Declare the paths a Stacks server-app WRITES at runtime as ts-cloud shared
+ * paths, so they are symlinked into each release instead of dying with it.
+ *
+ * Two separate failures are closed here.
+ *
+ * **A release owns the database.** `releases/<sha>/database/stacks.sqlite` was a
+ * real file inside the release the deploy had just unpacked: `migrate` (in
+ * preStart) built a brand new empty database, the release went live against it,
+ * and every production row written since the previous deploy was gone the moment
+ * the old release was pruned — silently, with nothing in the deploy output to
+ * say so. Verified on a live box: a sentinel row was gone after the next deploy.
+ *
+ * **A site owns the database.** Each site installs under its own base, so `main`
+ * and `api` both opened `database/stacks.sqlite` relative to their OWN release
+ * — two files, only one of them ever migrated. The database is therefore pointed
+ * at a project-level target ({@link projectDatabaseTarget}) that no site's name
+ * appears in, so siblings share one file by construction. Only the site that
+ * runs `migrate` may create or seed it; the rest link at it (`seed: false`), so
+ * deploy order cannot decide whose data wins.
+ *
+ * Logs stay site-scoped — `main` and `api` are different services and their logs
+ * should not interleave.
+ *
+ * Additive: a site's own `sharedPaths` in config/cloud.ts always survive, so an
+ * app can persist its own state (upload dirs, generated assets) the same way.
+ */
+export declare function applyPersistentStatePaths(sites: Record<string, any>, slug: string): Record<string, any>;
 /**
  * Make the site model environment-aware. For a non-production environment that
  * declares a `domainPrefix` (staging → `staging`, development → `dev`), every
@@ -54,10 +122,16 @@ export declare function mergeSiteDeployEnv(sites: Record<string, any>, resolvedD
  */
 export declare function applyEnvironmentToSites(sites: Record<string, any>, environment: string, config: any): Record<string, any>;
 /**
- * Load the ts-cloud driver used by Buddy. Published installs use the declared
- * package dependency. Framework and ts-cloud development can point at a built
- * local module with TS_CLOUD_MODULE, avoiding stale nested dependency copies
- * while still exercising the exact Buddy deploy path.
+ * Resolve the app's direct ts-cloud dependency before Buddy's own dependency.
+ * Package managers may retain a stale nested copy below Buddy even after the
+ * app explicitly updates ts-cloud; resolving from the project manifest keeps
+ * the deploy engine selected by the application authoritative.
+ */
+export declare function resolveProjectTsCloudModule(projectRoot?: unknown): string | undefined;
+/**
+ * Load the ts-cloud driver used by Buddy. An explicit TS_CLOUD_MODULE remains
+ * available for framework development; published apps otherwise use their
+ * direct dependency before falling back to Buddy's declared dependency.
  */
 export declare function loadTsCloudDeployApi(): Promise<typeof import('@stacksjs/ts-cloud')>;
 /**

package/dist/commands/deploy.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import process from "node:process";
 import { pathToFileURL } from "node:url";
 import { runAction } from "@stacksjs/actions";
@@ -479,6 +479,74 @@ export function mergeSiteDeployEnv(sites, resolvedDeployEnv) {
     return [siteName, { ...site, env: { ...base, ...site.env || {} } }];
   }));
 }
+function looksLikeSqliteFile(value) {
+  return typeof value === "string" && /\.(?:sqlite3?|db)$/i.test(value.trim());
+}
+export function siteSqlitePath(siteEnv = {}) {
+  if (String(siteEnv.DB_CONNECTION ?? "sqlite").trim().toLowerCase() !== "sqlite")
+    return null;
+  const configured = typeof siteEnv.DB_DATABASE_PATH === "string" && siteEnv.DB_DATABASE_PATH.trim() ? siteEnv.DB_DATABASE_PATH : looksLikeSqliteFile(siteEnv.DB_DATABASE) ? siteEnv.DB_DATABASE : "database/stacks.sqlite", path = String(configured).trim().replace(/^\.\//, "");
+  if (!path || path.startsWith("/") || path.startsWith("~") || path.split("/").includes(".."))
+    return null;
+  return path;
+}
+export function tsCloudPersistentStateSupport(buildSiteDeployScript) {
+  const missing = [];
+  if (typeof buildSiteDeployScript !== "function")
+    return { ok: !1, missing: ["buildSiteDeployScript"] };
+  const target = "/var/www/probe-shared/database/probe.sqlite";
+  let script = "";
+  try {
+    script = buildSiteDeployScript({
+      siteName: "probe",
+      slug: "probe",
+      appDir: "/var/www/probe-probe",
+      artifactFetch: [],
+      releaseId: "probe",
+      execStart: "/bin/true",
+      envEntries: {},
+      port: 3000,
+      sharedPaths: [{ path: "database/probe.sqlite", target, seed: !0 }]
+    }).join(`
+`);
+  } catch {
+    return { ok: !1, missing: ["shared paths with an explicit target"] };
+  }
+  if (!(script.includes("cp -a") && script.includes("/current/")))
+    missing.push("adoption of existing state into shared/");
+  if (!script.includes(`ln -sfn ${target} `))
+    missing.push("shared paths with an explicit target");
+  return { ok: missing.length === 0, missing };
+}
+export function projectDatabaseTarget(slug, relativePath) {
+  return `/var/www/${slug}-shared/${relativePath}`;
+}
+function runsMigrations(site) {
+  return Array.isArray(site?.preStart) && site.preStart.some((cmd) => typeof cmd === "string" && /\bmigrate\b/.test(cmd));
+}
+export function applyPersistentStatePaths(sites, slug) {
+  const isServerApp = (site) => !!site && typeof site.start === "string", appSites = Object.entries(sites).filter(([, site]) => isServerApp(site)), owner = (appSites.find(([, site]) => runsMigrations(site)) ?? appSites[0])?.[0], out = {};
+  for (const [name, site] of Object.entries(sites)) {
+    if (!isServerApp(site)) {
+      out[name] = site;
+      continue;
+    }
+    const sqlite = siteSqlitePath(site.env || {}), framework = [
+      "storage/logs"
+    ];
+    if (sqlite)
+      framework.unshift({
+        path: sqlite,
+        target: projectDatabaseTarget(slug, sqlite),
+        seed: name === owner
+      });
+    const declared = Array.isArray(site.sharedPaths) ? site.sharedPaths.filter(Boolean) : [], byPath = new Map;
+    for (const entry of [...declared, ...framework])
+      byPath.set(typeof entry === "string" ? entry : entry.path, entry);
+    out[name] = { ...site, sharedPaths: [...byPath.values()] };
+  }
+  return out;
+}
 function prefixHostForEnv(host, prefix) {
   if (host.startsWith(`${prefix}.`) || host.startsWith(`www.${prefix}.`))
     return host;
@@ -546,7 +614,13 @@ async function deployToHetzner(tsCloudConfig, deployEnv, options) {
     log.info("Generate one with:  ssh-keygen -t ed25519");
     process.exit(ExitCode.FatalError);
   }
-  const { createCloudDriver, deployAllComputeSites, ensureManagementDashboard, resolveSiteKind } = await loadTsCloudDeployApi();
+  const { createCloudDriver, deployAllComputeSites, ensureManagementDashboard, resolveSiteKind, buildSiteDeployScript } = await loadTsCloudDeployApi(), support = tsCloudPersistentStateSupport(buildSiteDeployScript);
+  if (!support.ok) {
+    log.error("This ts-cloud cannot keep your database across deploys, and deploying anyway would destroy it.");
+    log.error(`Missing: ${support.missing.join(", ")}.`);
+    log.error("Upgrade @stacksjs/ts-cloud (bun update @stacksjs/ts-cloud), or point TS_CLOUD_MODULE at a build that has it.");
+    process.exit(ExitCode.FatalError);
+  }
   try {
     await runHetznerDeploy({ tsCloudConfig, environment, verbose, docker: options.docker === !0, createCloudDriver, deployAllComputeSites, ensureManagementDashboard, resolveSiteKind, onlySite: options.site || void 0, persistedAttachBox });
   } catch (err) {
@@ -555,10 +629,22 @@ async function deployToHetzner(tsCloudConfig, deployEnv, options) {
     process.exit(ExitCode.FatalError);
   }
 }
+export function resolveProjectTsCloudModule(projectRoot = process.cwd()) {
+  const manifestPath = join(projectRoot, "node_modules", "@stacksjs", "ts-cloud", "package.json");
+  if (!existsSync(manifestPath))
+    return;
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8")), rootExport = manifest.exports?.["."], entry = manifest.module ?? (typeof rootExport === "string" ? rootExport : rootExport?.import);
+  if (!entry)
+    return;
+  const modulePath = resolve(dirname(manifestPath), entry);
+  return existsSync(modulePath) ? modulePath : void 0;
+}
 export async function loadTsCloudDeployApi() {
   const requested = process.env.TS_CLOUD_MODULE?.trim();
-  if (!requested)
-    return import("@stacksjs/ts-cloud");
+  if (!requested) {
+    const projectModule = resolveProjectTsCloudModule();
+    return projectModule ? import(pathToFileURL(projectModule).href) : import("@stacksjs/ts-cloud");
+  }
   const modulePath = isAbsolute(requested) ? requested : resolve(process.cwd(), requested);
   if (!existsSync(modulePath))
     throw Error(`TS_CLOUD_MODULE points to a missing module: ${modulePath}`);
@@ -865,7 +951,7 @@ async function runHetznerDeploy(args) {
   }
   if (docker)
     await buildContainerImageWithPantry({ slug, sites, verbose });
-  const resolvedDeployEnv = await resolveDeployEnvValues(environment, tsCloudConfig), sitesWithResolvedEnv = mergeSiteDeployEnv(sites, resolvedDeployEnv);
+  const resolvedDeployEnv = await resolveDeployEnvValues(environment, tsCloudConfig), sitesWithResolvedEnv = applyPersistentStatePaths(mergeSiteDeployEnv(sites, resolvedDeployEnv), slug);
   for (const [envKey, envValue] of Object.entries(resolvedDeployEnv))
     if (process.env[envKey] === void 0)
       process.env[envKey] = envValue;

package/dist/commands/generate.js

@@ -60,6 +60,20 @@ export function generate(buddy) {
       log.warn(`[generate:db-types] ${e.file}: ${e.error}`);
     log.info(`[generate:db-types] resolved ${result.tables.length} table(s)`);
   });
+  buddy.command("generate:vschema", "Derive a Vitess VSchema from your models (writes database/vschema.json)").option("--dry-run", "Print the VSchema without writing it", { default: !1 }).option("--out [path]", "Where to write the VSchema", { default: "database/vschema.json" }).action(async (options) => {
+    const { generateVSchema } = await import("@stacksjs/actions"), result = await generateVSchema({ dryRun: options.dryRun, out: options.out });
+    if (!result.ok) {
+      console.error(`
+\u274C ${result.error}
+`);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log(result.report);
+    if (options.dryRun)
+      console.log(JSON.stringify(result.vschema, null, 2));
+    else
+      log.success(`Wrote ${result.path} (${result.tableCount} tables)`);
+  });
   buddy.command("generate:entries", descriptions.entries).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
     log.debug("Running `buddy generate:entries` ...", options);
     await generateLibEntries(options);

package/dist/commands/lint.js

@@ -8,6 +8,39 @@ async function runStyleAction(entry, label, options) {
     process.exit(ExitCode.FatalError);
   }
 }
+async function runStxChecks(startTime) {
+  const { runStxLint } = await import("@stacksjs/actions"), report = await runStxLint(), out = [""];
+  for (const r of report.results)
+    if (r.status === "fail") {
+      out.push(`  FAIL  ${r.label}`);
+      out.push(`        ${r.count} found, baseline ${r.baseline}${r.why ? ` (${r.why})` : ""}`);
+      for (const line of r.detail.slice(0, 8))
+        out.push(`          ${line}`);
+    } else if (r.status === "loosened")
+      out.push(`  DROP  ${r.label}: ${r.count} < baseline ${r.baseline} \u2014 lower it in config/lint.ts`);
+    else
+      out.push(`  ok    ${r.label}${r.baseline > 0 ? `  (${r.count}, held)` : ""}`);
+  if (report.distMissing)
+    out.push("", "  note: no build output found \u2014 the dist checks did not run. Run `./buddy build` first.");
+  if (report.loosened > 0) {
+    out.push("", "  Current counts, for config/lint.ts:");
+    for (const [id, count] of Object.entries(report.counts).sort(([a], [b]) => a.localeCompare(b)))
+      out.push(`      '${id}': ${count},`);
+  }
+  console.log(out.join(`
+`));
+  if (report.failed > 0) {
+    log.error(`${report.failed} stx check(s) failed.`);
+    await outro("stx checks failed", { startTime, useSeconds: !0 });
+    process.exit(ExitCode.FatalError);
+  }
+  if (report.loosened > 0) {
+    log.warn(`No regressions, but ${report.loosened} baseline(s) are now stale.`);
+    await outro("stx baselines stale", { startTime, useSeconds: !0 });
+    process.exit(ExitCode.FatalError);
+  }
+  await outro("All stx checks pass", { startTime, useSeconds: !0 });
+}
 export function lint(buddy) {
   const descriptions = {
     lint: "Automagically lints your project codebase",
@@ -15,11 +48,16 @@ export function lint(buddy) {
     format: "Format your project codebase",
     formatCheck: "Check formatting without making changes",
     project: "Target a specific project",
+    stx: "Run the stx conformance checks instead of code style",
     verbose: "Enable verbose output"
   };
-  buddy.command("lint", descriptions.lint).option("-f, --fix", descriptions.lintFix, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+  buddy.command("lint", descriptions.lint).option("-f, --fix", descriptions.lintFix, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--stx", descriptions.stx, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
     log.debug("Running `buddy lint` ...", options);
     const startTime = await intro("buddy lint");
+    if (options.stx) {
+      await runStxChecks(startTime);
+      return;
+    }
     await runStyleAction(options.fix ? "lintFix" : "lintProject", "lint");
     await outro("Linted your project", { startTime, useSeconds: !0 });
   });

package/dist/commands/migrate.js

@@ -6,7 +6,7 @@ import { hasTTY, isCI } from "@stacksjs/env";
 import { appPath, frameworkPath, frameworkRuntimePath, projectPath } from "@stacksjs/path";
 import { ExitCode } from "@stacksjs/types";
 import { preflightDatabase } from "../database-preflight";
-import { DIALECT_OVERRIDE_ENV, auditMigrationCorpus, formatMigrationDialectError, stripSqlNoise } from "@stacksjs/database";
+import { DDL_CONSTRAINT_OVERRIDE_ENV, DIALECT_OVERRIDE_ENV, auditDdlConstraints, auditMigrationCorpus, dialectCapabilities, formatDdlConstraintError, formatMigrationDialectError, stripSqlNoise } from "@stacksjs/database";
 let _runAction;
 async function runAction(...args) {
   if (!_runAction)
@@ -85,15 +85,21 @@ function validateModelsExist() {
   return { valid: !0 };
 }
 function validateMigrationDialect() {
-  if (process.env[DIALECT_OVERRIDE_ENV] === "1")
-    return { valid: !0 };
-  const driver = String(process.env.DB_CONNECTION || "sqlite").toLowerCase(), target = driver === "singlestore" ? "mysql" : driver;
-  if (target !== "sqlite" && target !== "postgres" && target !== "mysql")
-    return { valid: !0 };
-  const dir = projectPath("database/migrations"), audit = auditMigrationCorpus({ dir, target });
-  if (audit.empty || audit.incompatible.length === 0)
-    return { valid: !0 };
-  return { valid: !1, error: formatMigrationDialectError(audit, target, "database/migrations") };
+  const driver = String(process.env.DB_CONNECTION || "sqlite").toLowerCase(), dir = projectPath("database/migrations");
+  if (process.env[DIALECT_OVERRIDE_ENV] !== "1") {
+    const caps = dialectCapabilities(driver), target = caps.wire === "mysql" ? "mysql" : caps.wire === "postgres" ? "postgres" : "sqlite";
+    if (driver === "sqlite" || driver === "postgres" || caps.wire === "mysql") {
+      const audit = auditMigrationCorpus({ dir, target });
+      if (!audit.empty && audit.incompatible.length > 0)
+        return { valid: !1, error: formatMigrationDialectError(audit, target, "database/migrations") };
+    }
+  }
+  if (process.env[DDL_CONSTRAINT_OVERRIDE_ENV] !== "1") {
+    const constraints = auditDdlConstraints({ dir, dialect: driver });
+    if (!constraints.empty && constraints.violations.length > 0)
+      return { valid: !1, error: formatDdlConstraintError(constraints, driver, "database/migrations") };
+  }
+  return { valid: !0 };
 }
 async function reportMissingForeignKeys() {
   try {
@@ -289,14 +295,20 @@ export function migrate(buddy) {
       log.error("Model migrations failed \u2014 applying notification/RBAC table guarantees before exiting.");
     if (options.auth !== !1)
       try {
-        const { migrateNotificationTables, migrateRbacTables } = await import("@stacksjs/database"), notifResult = await migrateNotificationTables({ verbose: options.verbose });
+        const { ensureUtcDatetimeColumns, migrateNotificationTables, migrateRbacTables, migrateTraitTables } = await import("@stacksjs/database"), notifResult = await migrateNotificationTables({ verbose: options.verbose });
         if (!notifResult.success)
           log.error(`Failed to migrate notification tables: ${notifResult.error}`);
         const rbacResult = await migrateRbacTables({ verbose: options.verbose });
         if (!rbacResult.success)
           log.error(`Failed to migrate RBAC tables: ${rbacResult.error}`);
+        const traitResult = await migrateTraitTables({ verbose: options.verbose });
+        if (!traitResult.success)
+          log.error(`Failed to migrate polymorphic trait tables: ${traitResult.error}`);
+        const datetimeResult = await ensureUtcDatetimeColumns({ verbose: options.verbose });
+        if (!datetimeResult.success)
+          log.error(`Failed to convert TIMESTAMP columns to DATETIME: ${datetimeResult.error}`);
       } catch (error) {
-        log.error("Failed to migrate notification/RBAC tables:", error);
+        log.error("Failed to migrate notification/RBAC/trait tables:", error);
       }
     if (result.isErr) {
       await outro("While running the migrate command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
@@ -371,7 +383,7 @@ export function migrate(buddy) {
     if (options.auth !== !1) {
       log.debug("Migrating auth tables...");
       try {
-        const { migrateAuthTables, migrateNotificationTables, migrateRbacTables } = await import("@stacksjs/database"), authResult = await migrateAuthTables({ verbose: options.verbose });
+        const { migrateAuthTables, migrateNotificationTables, migrateRbacTables, migrateTraitTables } = await import("@stacksjs/database"), authResult = await migrateAuthTables({ verbose: options.verbose });
         if (!authResult.success)
           log.error(`Failed to migrate auth tables: ${authResult.error}`);
         const notifResult = await migrateNotificationTables({ verbose: options.verbose });
@@ -380,8 +392,11 @@ export function migrate(buddy) {
         const rbacResult = await migrateRbacTables({ verbose: options.verbose });
         if (!rbacResult.success)
           log.error(`Failed to migrate RBAC tables: ${rbacResult.error}`);
+        const traitResult = await migrateTraitTables({ verbose: options.verbose });
+        if (!traitResult.success)
+          log.error(`Failed to migrate polymorphic trait tables: ${traitResult.error}`);
       } catch (error) {
-        log.error("Failed to migrate auth/notification/RBAC tables:", error);
+        log.error("Failed to migrate auth/notification/RBAC/trait tables:", error);
       }
     }
     try {

package/dist/production-server.d.ts

@@ -1,35 +1 @@
-/**
- * Resolve the project's includes directory.
- *
- * A configured `config/stx.ts#partialsDir` wins outright. The convention list
- * below is only a fallback for apps that never set one, and it cannot stand in
- * for the config: the candidates are probed for existence in order, so an app
- * that keeps its includes in `resources/components` but also has an unrelated
- * `resources/partials` directory silently resolved to the wrong one and every
- * `@include` failed with ENOENT at runtime.
- *
- * The configured value is relative to the stx root (`resources`), matching how
- * stx itself reads it, but an app-root-relative path is accepted too so either
- * spelling resolves.
- */
-export declare function resolveUserPartialsPath(cwd?: unknown, configuredDir?: string): string | undefined;
-/**
- * Read `partialsDir` off the app's stx config. Failure is non-fatal: without
- * it {@link resolveUserPartialsPath} falls back to the conventions.
- */
-export declare function loadStxPartialsDir(cwd?: unknown): Promise<string | undefined>;
-/**` proxy target, or `null` when it cannot be
- * known safely.
- *
- * `API_URL` and `PORT_API` are explicit operator intent and always win. The
- * framework-wide `ports.api` default is only trusted *outside* deployed
- * environments: locally one app owns the machine, so `127.0.0.1:3008` really is
- * its own API. On a deployed box that assumption does not hold — ts-cloud runs
- * many SSR sites side by side, each on its own port, and an unconfigured
- * default resolves to whichever tenant happens to own it.
- *
- * Returning `null` makes the caller answer 502. That is the safe failure: the
- * alternative is proxying authenticated requests into another app's process.
- */
-export declare function resolveApiBase(configuredPort?: number, env?: NodeJS.ProcessEnv): string | null;
-export declare function startProductionServer(options?: { port?: string | number, verbose?: boolean }): Promise<void>;
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/buddy",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.256",
+  "version": "0.70.258",
   "description": "Meet Buddy. The Stacks runtime.",
   "author": "Chris Breuer",
   "contributors": [
@@ -88,54 +88,54 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/actions": "^0.70.256",
-    "@stacksjs/ai": "^0.70.256",
-    "@stacksjs/alias": "^0.70.256",
-    "@stacksjs/arrays": "^0.70.256",
-    "@stacksjs/auth": "^0.70.256",
-    "@stacksjs/build": "^0.70.256",
-    "@stacksjs/cache": "^0.70.256",
-    "@stacksjs/cli": "^0.70.256",
+    "@stacksjs/actions": "^0.70.258",
+    "@stacksjs/ai": "^0.70.258",
+    "@stacksjs/alias": "^0.70.258",
+    "@stacksjs/arrays": "^0.70.258",
+    "@stacksjs/auth": "^0.70.258",
+    "@stacksjs/build": "^0.70.258",
+    "@stacksjs/cache": "^0.70.258",
+    "@stacksjs/cli": "^0.70.258",
     "@stacksjs/clapp": "^0.2.12",
-    "@stacksjs/cloud": "^0.70.256",
-    "@stacksjs/collections": "^0.70.256",
-    "@stacksjs/config": "^0.70.256",
-    "@stacksjs/database": "^0.70.256",
-    "@stacksjs/desktop-build": "^0.70.256",
-    "@stacksjs/dns": "^0.70.256",
-    "@stacksjs/email": "^0.70.256",
-    "@stacksjs/enums": "^0.70.256",
-    "@stacksjs/error-handling": "^0.70.256",
-    "@stacksjs/events": "^0.70.256",
-    "@stacksjs/git": "^0.70.256",
+    "@stacksjs/cloud": "^0.70.258",
+    "@stacksjs/collections": "^0.70.258",
+    "@stacksjs/config": "^0.70.258",
+    "@stacksjs/database": "^0.70.258",
+    "@stacksjs/desktop-build": "^0.70.258",
+    "@stacksjs/dns": "^0.70.258",
+    "@stacksjs/email": "^0.70.258",
+    "@stacksjs/enums": "^0.70.258",
+    "@stacksjs/error-handling": "^0.70.258",
+    "@stacksjs/events": "^0.70.258",
+    "@stacksjs/git": "^0.70.258",
     "@stacksjs/gitit": "^0.2.5",
-    "@stacksjs/health": "^0.70.256",
+    "@stacksjs/health": "^0.70.258",
     "@stacksjs/dnsx": "^0.2.3",
     "@stacksjs/httx": "^0.1.10",
-    "@stacksjs/image": "^0.70.256",
-    "@stacksjs/lint": "^0.70.256",
-    "@stacksjs/logging": "^0.70.256",
-    "@stacksjs/notifications": "^0.70.256",
-    "@stacksjs/objects": "^0.70.256",
-    "@stacksjs/orm": "^0.70.256",
-    "@stacksjs/path": "^0.70.256",
-    "@stacksjs/skills": "^0.70.256",
-    "@stacksjs/payments": "^0.70.256",
-    "@stacksjs/realtime": "^0.70.256",
-    "@stacksjs/router": "^0.70.256",
+    "@stacksjs/image": "^0.70.258",
+    "@stacksjs/lint": "^0.70.258",
+    "@stacksjs/logging": "^0.70.258",
+    "@stacksjs/notifications": "^0.70.258",
+    "@stacksjs/objects": "^0.70.258",
+    "@stacksjs/orm": "^0.70.258",
+    "@stacksjs/path": "^0.70.258",
+    "@stacksjs/skills": "^0.70.258",
+    "@stacksjs/payments": "^0.70.258",
+    "@stacksjs/realtime": "^0.70.258",
+    "@stacksjs/router": "^0.70.258",
     "@stacksjs/rpx": "^0.11.42",
-    "@stacksjs/search-engine": "^0.70.256",
-    "@stacksjs/security": "^0.70.256",
-    "@stacksjs/server": "^0.70.256",
-    "@stacksjs/storage": "^0.70.256",
-    "@stacksjs/strings": "^0.70.256",
-    "@stacksjs/testing": "^0.70.256",
-    "@stacksjs/tunnel": "^0.70.256",
-    "@stacksjs/types": "^0.70.256",
-    "@stacksjs/ui": "^0.70.256",
-    "@stacksjs/utils": "^0.70.256",
-    "@stacksjs/validation": "^0.70.256",
-    "@stacksjs/ts-cloud": "^0.7.92",
+    "@stacksjs/search-engine": "^0.70.258",
+    "@stacksjs/security": "^0.70.258",
+    "@stacksjs/server": "^0.70.258",
+    "@stacksjs/storage": "^0.70.258",
+    "@stacksjs/strings": "^0.70.258",
+    "@stacksjs/testing": "^0.70.258",
+    "@stacksjs/tunnel": "^0.70.258",
+    "@stacksjs/types": "^0.70.258",
+    "@stacksjs/ui": "^0.70.258",
+    "@stacksjs/utils": "^0.70.258",
+    "@stacksjs/validation": "^0.70.258",
+    "@stacksjs/ts-cloud": "^0.7.94",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "ts-pantry": "^0.11.0"