@voltro/cli 0.51.0 → 0.53.0

package/templates/apps/frontend-ssr/package.json

@@ -12,17 +12,17 @@
     "test": "voltro test"
   },
   "dependencies": {
-    "@voltro/cli": "0.51.0",
-    "@voltro/client": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/i18n": "0.51.0",
-    "@voltro/ui-shadcn": "0.51.0",
-    "@voltro/web": "0.51.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/client": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/i18n": "0.53.0",
+    "@voltro/ui-shadcn": "0.53.0",
+    "@voltro/web": "0.53.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@voltro/devtools": "0.51.0",
+    "@voltro/devtools": "0.53.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "jsdom": "^30.0.0",

package/templates/apps/frontend-ssr-api/package.json

@@ -12,18 +12,18 @@
     "test": "voltro test"
   },
   "dependencies": {
-    "@{{projectName}}/api": "0.51.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/client": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/i18n": "0.51.0",
-    "@voltro/ui-shadcn": "0.51.0",
-    "@voltro/web": "0.51.0",
+    "@{{projectName}}/api": "0.53.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/client": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/i18n": "0.53.0",
+    "@voltro/ui-shadcn": "0.53.0",
+    "@voltro/web": "0.53.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@voltro/devtools": "0.51.0",
+    "@voltro/devtools": "0.53.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "jsdom": "^30.0.0",

package/templates/apps/frontend-static-blog/content/posts/cms-to-ssg.md

@@ -0,0 +1,12 @@
+---
+title: From CMS to static pages with getStaticPaths
+date: 2025-02-03
+excerpt: Enumerate your content once; the build emits one pre-rendered page per entry.
+readingMinutes: 3
+---
+
+A dynamic route like `src/pages/blog/[slug].tsx` matches infinitely many URLs. To pre-render it statically, the build needs to know WHICH slugs exist — that is what `getStaticPaths` answers.
+
+In this template, `getStaticPaths` maps over the `posts` array in `src/content/posts.ts`. Point it at a CMS API, a database query, or a folder of markdown files instead, and the build will pre-render exactly those pages — the Next.js "static generation from a content source" pattern, with no extra config.
+
+URLs you do not enumerate simply are not built. If a page ALSO sets `renderMode = 'ssr' | 'isr'`, `voltro start` renders the un-enumerated ones on demand; a pure `'static'` page 404s for unknown slugs, which is exactly what you want for a fixed content set.

package/templates/apps/frontend-static-blog/content/posts/hello-static.md

@@ -0,0 +1,12 @@
+---
+title: Why this blog ships zero JavaScript
+date: 2025-01-15
+excerpt: Every page is pre-rendered at build time, so the browser downloads HTML and nothing else.
+readingMinutes: 3
+---
+
+This page was rendered ONCE, when you ran `voltro build`. The result is a flat `dist/blog/hello-static/index.html` that any CDN can serve in single-digit milliseconds.
+
+There is no server rendering per request, no React hydration on the list page, no rpc client on the wire. The list page even declares `interactive = 'none'`, which strips every `<script>` the framework would otherwise emit.
+
+When you DO need a sprinkle of interactivity — a reading-progress bar, a copy button, a comment box — you reach for an island instead of hydrating the whole tree. Read the next post for how that works.

package/templates/apps/frontend-static-blog/content/posts/islands-not-hydration.md

@@ -0,0 +1,14 @@
+---
+title: Islands: hydrate the 5% that moves
+date: 2025-01-22
+excerpt: A static page with one interactive widget should ship one widget of JavaScript — not the whole page.
+readingMinutes: 4
+---
+
+Look at the top of this page: a thin progress bar tracks how far you have scrolled. That bar is an ISLAND — a single component the framework hydrates inside otherwise-static HTML.
+
+This page declares `interactive = 'islands'`, so the framework renders the article once and only attaches React to the `island()`-wrapped component. The surrounding HTML has zero React lifecycle running.
+
+Each island picks WHEN it wakes up via a hydrate strategy: `load` (immediately), `idle`, `visible` (on scroll-into-view), or `interaction` (on first click). The progress bar uses `load` because it must track scrolling from the very first frame.
+
+The lesson: don't default to `islands` because it sounds fast. Use it when most of the page is static and only a few widgets move. A dashboard where everything is interactive wants `full` hydration instead.

package/templates/apps/frontend-static-blog/package.json

@@ -12,16 +12,18 @@
     "test": "voltro test"
   },
   "dependencies": {
-    "@voltro/cli": "0.51.0",
-    "@voltro/client": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/i18n": "0.51.0",
-    "@voltro/web": "0.51.0",
+    "@voltro/content": "0.53.0",
+    "effect": "^3.22.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/client": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/i18n": "0.53.0",
+    "@voltro/web": "0.53.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@voltro/devtools": "0.51.0",
+    "@voltro/devtools": "0.53.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "jsdom": "^30.0.0",

package/templates/apps/frontend-static-blog/src/collections/posts.collection.ts

@@ -0,0 +1,27 @@
+// The blog's content collection — content/posts/**/*.md through the
+// framework's content pipeline (@voltro/content). Frontmatter is
+// schema-checked at build time (a violation FAILS the build naming the file),
+// bodies render to HTML with syntax-highlighted code fences, and no markdown
+// engine ships to the browser: SSG reads the filesystem; SPA navigations
+// fetch the build-emitted JSON artifacts under /assets/content/posts/.
+//
+// Point a CMS/DB-backed site at @voltro/cms instead — files are versioned
+// DEVELOPER content, a CMS is editorial content.
+
+import { Schema } from 'effect'
+import { defineCollection } from '@voltro/content'
+
+export const posts = defineCollection({
+  name: 'posts',
+  directory: 'content/posts',
+  schema: Schema.Struct({
+    title: Schema.String,
+    /** ISO date, shown + used for ordering. */
+    date: Schema.String,
+    /** One-line summary — feeds the list + `<meta name="description">`. */
+    excerpt: Schema.String,
+    readingMinutes: Schema.Union(Schema.NumberFromString, Schema.Number),
+  }),
+})
+
+export type Post = Schema.Schema.Type<typeof posts.schema>

package/templates/apps/frontend-static-blog/src/pages/[locale]/blog/[slug]/page.tsx

@@ -7,14 +7,17 @@
 // once per non-default locale). `voltro build` produces one HTML file per
 // pair, e.g. /de/blog/hello-static.
 import { SUPPORTED_LOCALES, DEFAULT_LOCALE } from '../../../../lib/locale'
-import { posts } from '../../../../content/posts'
+import { getCollection } from '@voltro/content'
+import { posts } from '../../../../collections/posts.collection'
 
 export { default } from '../../../blog/[slug]/page'
 export { renderMode, interactive, loader, meta } from '../../../blog/[slug]/page'
 
 export const getStaticPaths = async (): Promise<
   Array<{ params: { locale: string; slug: string } }>
-> =>
-  SUPPORTED_LOCALES
+> => {
+  const entries = await getCollection(posts.name)
+  return SUPPORTED_LOCALES
     .filter((l) => l !== DEFAULT_LOCALE)
-    .flatMap((locale) => posts.map((post) => ({ params: { locale, slug: post.slug } })))
+    .flatMap((locale) => entries.map((post) => ({ params: { locale, slug: post.slug } })))
+}

package/templates/apps/frontend-static-blog/src/pages/[locale]/mirrors.test.tsx

@@ -8,7 +8,13 @@
 
 import { describe, expect, test, vi } from 'vitest'
 import type { ComponentType } from 'react'
-import { posts } from '../../content/posts'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { setContentRoot, getCollection } from '@voltro/content'
+import { posts as postsCollection } from '../../collections/posts.collection'
+
+setContentRoot(join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..'))
+const posts = await getCollection(postsCollection.name)
 
 // The mirrors transitively import the base pages, which import @voltro/web
 // (island / loader / notFound / useLocation via lib/locale) and @voltro/i18n.

package/templates/apps/frontend-static-blog/src/pages/blog/[slug]/page.test.tsx

@@ -10,10 +10,16 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 import { act, createElement, type ComponentType, type ReactNode } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
-import { posts, type Post } from '../../../content/posts'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { setContentRoot, getCollection, type ContentEntry } from '@voltro/content'
+import { posts as postsCollection, type Post } from '../../../collections/posts.collection'
 import en from '../../../locales/en'
 
-const loaderData = vi.fn<() => Post>()
+// Real content: the collection reads this app's content/posts/*.md.
+setContentRoot(join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..'))
+
+const loaderData = vi.fn<() => ContentEntry<Post>>()
 
 const fill = (msg: string, values?: Record<string, unknown>): string =>
   values ? msg.replace(/\{(\w+)\}/g, (_, k: string) => String(values[k] ?? `{${k}}`)) : msg
@@ -48,6 +54,7 @@ vi.mock('@voltro/i18n', () => ({
 }))
 
 const { default: BlogPost, getStaticPaths, loader, meta } = await import('./page')
+const posts = await getCollection<Post>(postsCollection.name)
 
 ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
 
@@ -76,6 +83,7 @@ afterEach(() => {
 describe('blog [slug] — getStaticPaths', () => {
   test('enumerates one path per post', async () => {
     const paths = await getStaticPaths()
+    expect(posts.length).toBeGreaterThan(0)
     expect(paths.map((p) => p.params.slug)).toEqual(posts.map((p) => p.slug))
   })
 })
@@ -84,7 +92,9 @@ describe('blog [slug] — loader', () => {
   test('returns the matching post for a known slug', async () => {
     const post = await loader({ params: { slug: 'hello-static' } } as never)
     expect(post.slug).toBe('hello-static')
-    expect(post.title).toContain('zero JavaScript')
+    expect(post.data.title).toContain('zero JavaScript')
+    // The loader returns RENDERED html — the component never sees markdown.
+    expect(post.html).toContain('<p>')
   })
 
   test('throws notFound for an unknown slug', async () => {
@@ -98,8 +108,8 @@ describe('blog [slug] — meta', () => {
   test('builds a per-post title + description from the loader data', () => {
     const post = posts[0]!
     const m = meta({ loaderData: post })
-    expect(m.title).toContain(post.title)
-    expect(m.description).toBe(post.excerpt)
+    expect(m.title).toContain(post.data.title)
+    expect(m.description).toBe(post.data.excerpt)
   })
 })
 
@@ -108,9 +118,9 @@ describe('blog [slug] — render', () => {
     const post = posts[1]!
     loaderData.mockReturnValue(post)
     render(createElement(BlogPost))
-    expect(container.querySelector('article h1')?.textContent).toBe(post.title)
-    expect(container.textContent).toContain(`${post.readingMinutes} min read`)
-    const paras = post.body.split('\n\n')
-    expect(container.querySelectorAll('article p').length).toBeGreaterThanOrEqual(paras.length)
+    expect(container.querySelector('article h1')?.textContent).toBe(post.data.title)
+    expect(container.textContent).toContain(`${post.data.readingMinutes} min read`)
+    // The body arrives as rendered html paragraphs.
+    expect(container.querySelectorAll('article div p').length).toBeGreaterThanOrEqual(2)
   })
 })

package/templates/apps/frontend-static-blog/src/pages/blog/[slug]/page.tsx

@@ -1,9 +1,11 @@
 // A dynamic route — `/blog/<slug>` — pre-rendered STATICALLY, one HTML
 // file per post. Three exports make that work:
 //
-//   • getStaticPaths  → enumerate which slugs to build (from the content
-//                        source; point it at a CMS/DB in a real app).
-//   • loader          → fetch THIS post's data; runs at build per slug.
+//   • getStaticPaths  → enumerate which slugs to build (from the `posts`
+//                        content collection — one .md file per post).
+//   • loader          → fetch THIS post's entry; runs at build per slug and
+//                        returns the RENDERED html (code fences highlighted
+//                        server-side; nothing markdown-shaped in the bundle).
 //   • meta(loaderData)→ per-post <title>/<description> baked into the HTML.
 //
 // `interactive: 'islands'` hydrates ONLY the <ReadingProgress> island; the
@@ -11,8 +13,9 @@
 
 import type { ReactNode } from 'react'
 import { useLoaderData, notFound, type LoaderFn, type PageMeta } from '@voltro/web'
+import { getCollection, getEntry, type ContentEntry } from '@voltro/content'
 import { T, useLocale } from '@voltro/i18n'
-import { posts, type Post } from '../../../content/posts'
+import { posts, type Post } from '../../../collections/posts.collection'
 import { withLocalePrefix } from '../../../lib/locale'
 import ReadingProgress from '../../../components/ReadingProgress.island'
 
@@ -22,14 +25,13 @@ export const interactive = 'islands' as const
 // Which concrete paths to pre-render. Every returned `params` becomes one
 // built HTML file; un-enumerated slugs are simply not built (→ 404).
 export const getStaticPaths = async (): Promise<Array<{ params: { slug: string } }>> =>
-  posts.map((post) => ({ params: { slug: post.slug } }))
+  (await getCollection(posts.name)).map((post) => ({ params: { slug: post.slug } }))
 
 // Runs at build time for each enumerated slug. Returning `notFound()` skips
-// the artifact at build / 404s at runtime — defensive, though getStaticPaths
-// only ever feeds us slugs that exist.
-export const loader: LoaderFn<Post> = async ({ params }) => {
-  const post = posts.find((p) => p.slug === params.slug)
-  if (!post) return notFound(`post ${params.slug}`)
+// the artifact at build / 404s at runtime.
+export const loader: LoaderFn<ContentEntry<Post>> = async ({ params }) => {
+  const post = await getEntry<Post>(posts.name, params.slug)
+  if (post === null) return notFound(`post ${params.slug}`)
   return post
 }
 
@@ -37,15 +39,13 @@ export const loader: LoaderFn<Post> = async ({ params }) => {
 // pre-rendered HTML (great for SEO + social cards). The title/description are
 // POST CONTENT, not chrome, so they are the same on `/blog/x` and `/de/blog/x`
 // — no per-locale variant needed here.
-export const meta = ({ loaderData }: { loaderData: Post }): PageMeta => ({
-  title: `${loaderData.title} — {{capProjectName}}`,
-  description: loaderData.excerpt,
+export const meta = ({ loaderData }: { loaderData: ContentEntry<Post> }): PageMeta => ({
+  title: `${loaderData.data.title} — {{capProjectName}}`,
+  description: loaderData.data.excerpt,
 })
 
 export default function BlogPost(): ReactNode {
-  const post = useLoaderData<Post>()
-  // The active locale (from the layout's URL provider) keeps the "all posts"
-  // link on the current language.
+  const post = useLoaderData<ContentEntry<Post>>()
   const locale = useLocale()
   return (
     <main>
@@ -56,13 +56,11 @@ export default function BlogPost(): ReactNode {
         </a>
       </p>
       <article>
-        <h1>{post.title}</h1>
+        <h1>{post.data.title}</h1>
         <p className="muted">
-          {post.date} · <T id="post.readingTimeRead" values={{ minutes: post.readingMinutes }} />
+          {post.data.date} · <T id="post.readingTimeRead" values={{ minutes: post.data.readingMinutes }} />
         </p>
-        {post.body.split('\n\n').map((para, i) => (
-          <p key={i}>{para}</p>
-        ))}
+        <div dangerouslySetInnerHTML={{ __html: post.html ?? '' }} />
       </article>
     </main>
   )

package/templates/apps/frontend-static-blog/src/pages/page.test.tsx

@@ -12,10 +12,16 @@
 import { afterEach, describe, expect, test, vi } from 'vitest'
 import { act, createElement, type ReactNode } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
-import { posts } from '../content/posts'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { setContentRoot } from '@voltro/content'
 import en from '../locales/en'
 import de from '../locales/de'
 
+// The list now comes from the posts CONTENT COLLECTION — point the server
+// half at this app's root and load the REAL content/posts/*.md files.
+setContentRoot(join(dirname(fileURLToPath(import.meta.url)), '..', '..'))
+
 const catalogs: Record<string, Record<string, string>> = { en, de }
 let currentLocale = 'en'
 
@@ -23,6 +29,10 @@ let currentLocale = 'en'
 const fill = (msg: string, values?: Record<string, unknown>): string =>
   values ? msg.replace(/\{(\w+)\}/g, (_, k: string) => String(values[k] ?? `{${k}}`)) : msg
 
+vi.mock('@voltro/web', () => ({
+  useLoaderData: () => entries,
+}))
+
 vi.mock('@voltro/i18n', () => ({
   // The locale catalogs call these at module top-level; identity mirrors the
   // real (compile-time-only) implementations so importing them doesn't throw.
@@ -38,7 +48,9 @@ vi.mock('@voltro/i18n', () => ({
     fill(catalogs[currentLocale]?.[id] ?? id, values),
 }))
 
-const { default: Index, meta, renderMode, interactive } = await import('./page')
+const { default: Index, meta, renderMode, interactive, loader } = await import('./page')
+// The real markdown entries, loaded through the real collection pipeline.
+const entries = await loader()
 
 ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
 
@@ -83,11 +95,12 @@ describe('index — localized render', () => {
     currentLocale = 'en'
     render(createElement(Index))
     const links = Array.from(container.querySelectorAll('.post-list a'))
-    expect(links).toHaveLength(posts.length)
+    expect(links).toHaveLength(entries.length)
+    expect(entries.length).toBeGreaterThan(0)
     // Newest-first: the 2025-02-03 post precedes the 2025-01-15 one.
     expect(links[0]!.getAttribute('href')).toBe('/blog/cms-to-ssg')
     expect(links[links.length - 1]!.getAttribute('href')).toBe('/blog/hello-static')
-    expect(container.textContent).toContain(`${posts.length} posts`)
+    expect(container.textContent).toContain(`${entries.length} posts`)
   })
 
   test('prefixes post links with /de and renders German chrome (de)', () => {
@@ -95,6 +108,6 @@ describe('index — localized render', () => {
     render(createElement(Index))
     const links = Array.from(container.querySelectorAll('.post-list a'))
     expect(links[0]!.getAttribute('href')).toBe('/de/blog/cms-to-ssg')
-    expect(container.textContent).toContain(`${posts.length} Beiträge`)
+    expect(container.textContent).toContain(`${entries.length} Beiträge`)
   })
 })

package/templates/apps/frontend-static-blog/src/pages/page.tsx

@@ -1,18 +1,22 @@
 // Blog index, mounted at `/` (default locale) and mirrored at `/de` by
-// src/pages/[locale]/index.tsx. The post LIST is pure content — no
+// src/pages/[locale]/page.tsx. The post LIST is pure content — no
 // interactivity — so it ships zero JavaScript: `interactive = 'none'` strips
-// every framework <script> from the rendered HTML. The list is read from the
-// same content source the [slug] pages + getStaticPaths use.
+// every framework <script> from the rendered HTML.
+//
+// The list comes from the `posts` CONTENT COLLECTION (content/posts/*.md):
+// the loader runs at build time and reads the filesystem — markdown with
+// schema-checked frontmatter, no markdown dependency in this app.
 //
 // `meta` is a FUNCTION of `{ locale }` — that's what localises each variant's
 // <title> / <description> in the pre-rendered HTML. Post titles/excerpts are
-// CONTENT (src/content/posts.ts) and are NOT translated; only the chrome
-// (heading, count line, reading-time label) comes from the catalogs.
+// CONTENT and are NOT translated; only the chrome (heading, count line,
+// reading-time label) comes from the catalogs.
 
 import type { ReactNode } from 'react'
-import type { PageMeta } from '@voltro/web'
+import { useLoaderData, type PageMeta } from '@voltro/web'
+import { getCollection, type ContentEntry } from '@voltro/content'
 import { T, useLocale } from '@voltro/i18n'
-import { posts } from '../content/posts'
+import { posts, type Post } from '../collections/posts.collection'
 import { getCatalog, withLocalePrefix } from '../lib/locale'
 
 export const renderMode = 'static' as const
@@ -26,10 +30,13 @@ export const meta = ({ locale }: { locale: string }): PageMeta => {
   }
 }
 
-// Newest first — sort a copy so the source array stays stable.
-const byDateDesc = [...posts].sort((a, b) => b.date.localeCompare(a.date))
+// Newest first. Runs once at build time (this page is static).
+export const loader = async (): Promise<ReadonlyArray<ContentEntry<Post>>> =>
+  [...await getCollection<Post>(posts.name)]
+    .sort((a, b) => b.data.date.localeCompare(a.data.date))
 
 export default function Index(): ReactNode {
+  const entries = useLoaderData<ReadonlyArray<ContentEntry<Post>>>()
   const locale = useLocale()
   return (
     <main>
@@ -37,18 +44,18 @@ export default function Index(): ReactNode {
         <T id="home.heading" />
       </h1>
       <p className="muted">
-        <T id="home.postCount" values={{ count: posts.length }} />
+        <T id="home.postCount" values={{ count: entries.length }} />
       </p>
       <ul className="post-list">
-        {byDateDesc.map((post) => (
+        {entries.map((post) => (
           <li key={post.slug}>
-            <a href={withLocalePrefix(`/blog/${post.slug}`, locale)}>{post.title}</a>
+            <a href={withLocalePrefix(`/blog/${post.slug}`, locale)}>{post.data.title}</a>
             <p>
               <span className="muted">
-                {post.date} · <T id="post.readingTime" values={{ minutes: post.readingMinutes }} />
+                {post.data.date} · <T id="post.readingTime" values={{ minutes: post.data.readingMinutes }} />
               </span>
               {' — '}
-              {post.excerpt}
+              {post.data.excerpt}
             </p>
           </li>
         ))}

package/templates/apps/frontend-status/package.json

@@ -12,18 +12,18 @@
     "test": "voltro test"
   },
   "dependencies": {
-    "@{{projectName}}/api": "0.51.0",
-    "@voltro/cli": "0.51.0",
-    "@voltro/client": "0.51.0",
-    "@voltro/env": "0.51.0",
-    "@voltro/i18n": "0.51.0",
-    "@voltro/ui-shadcn": "0.51.0",
-    "@voltro/web": "0.51.0",
+    "@{{projectName}}/api": "0.53.0",
+    "@voltro/cli": "0.53.0",
+    "@voltro/client": "0.53.0",
+    "@voltro/env": "0.53.0",
+    "@voltro/i18n": "0.53.0",
+    "@voltro/ui-shadcn": "0.53.0",
+    "@voltro/web": "0.53.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@voltro/devtools": "0.51.0",
+    "@voltro/devtools": "0.53.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "jsdom": "^30.0.0",

package/templates/apps/mobile-app/package.json

@@ -15,9 +15,9 @@
   "dependencies": {
     "@react-native-async-storage/async-storage": "1.23.1",
     "@react-native-community/netinfo": "11.4.1",
-    "@voltro/client": "0.51.0",
-    "@voltro/react-native": "0.51.0",
-    "@{{projectName}}/api": "0.51.0",
+    "@voltro/client": "0.53.0",
+    "@voltro/react-native": "0.53.0",
+    "@{{projectName}}/api": "0.53.0",
     "expo": "^52.0.0",
     "expo-constants": "~17.0.0",
     "expo-linking": "~7.0.0",
@@ -32,7 +32,7 @@
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@vitest/coverage-v8": "^4.1.10",
-    "@voltro/cli": "0.51.0",
+    "@voltro/cli": "0.53.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }

package/dist/agentsMd-Bu_XQgVf.js

@@ -1,2 +0,0 @@
-import { a as e } from "./agentsMd-D6yD7IQv.js";
-export { e as runAgentsMd };

package/dist/apiBuild-GDKuGOMV.js

@@ -1,2 +0,0 @@
-import { c as e, l as t } from "./apiBuild-CPDHXF72.js";
-export { e as runApiBuild, t as runServeBundleBuild };