@ultimat3/cli 5.0.1 → 7.0.0

package/src/templates/resource.ts

@@ -13,7 +13,8 @@ import type { GeneratedFile, NameSet } from './naming';
 import { names, pascal } from './naming';
 import { policyFiles } from './policy';
 import { queryFiles } from './query';
-import { routeFiles } from './route';
+import { formIslandFiles } from './resource-form-island';
+import { routeDir, routeFiles } from './route';
 
 const serviceSource = (
   feature: NameSet,
@@ -58,12 +59,29 @@ unitTest('${feature.pascal}NotFoundError carries a code, a cause and a fix', ()
 });
 `;
 
+/**
+ * The generated component reaches strings through the APP's catalog module — the one that calls
+ * `defineCatalogs()` — so a component that renders a string depends on the module that registers
+ * them. `t` from `@ultimat3/i18n` renders while depending on nothing, which is how a shipped app
+ * served every string as a loud miss with a green gate (issue #249). An app with no catalog module
+ * keeps the framework import: emitting one that cannot resolve is worse than the wrong idiom.
+ */
+const catalogImport = (module: string | undefined): string =>
+  module === undefined
+    ? "import { t } from '@ultimat3/i18n';"
+    : `import { useT } from '${module}';`;
+
+/** `useT()` is per render, so each component binds it in its own body. */
+const translatorBinding = (module: string | undefined): string =>
+  module === undefined ? '' : '\n  const t = useT();\n';
+
 const uiSource = (
   feature: NameSet,
+  module: string | undefined,
 ): string => `// Presentation only. No fetching, no business logic: the list arrives as a prop from the route,
 // which got it from the live query.
 
-import { t } from '@ultimat3/i18n';
+${catalogImport(module)}
 import { For } from 'solid-js';
 import type { ${feature.pascal} } from './entity';
 import styles from './ui.module.scss';
@@ -72,7 +90,7 @@ export interface ${feature.pascal}ListProps {
   readonly rows: readonly ${feature.pascal}[];
 }
 
-export function ${feature.pascal}List(props: ${feature.pascal}ListProps) {
+export function ${feature.pascal}List(props: ${feature.pascal}ListProps) {${translatorBinding(module)}
   return (
     <ul class={styles.list}>
       <For each={props.rows} fallback={<li>{t('app.${feature.kebab}.empty')}</li>}>
@@ -103,10 +121,11 @@ const uiStyle = (): string => `@use '@ultimat3/ui/tokens' as tokens;
 
 const cardSource = (
   feature: NameSet,
+  module: string | undefined,
 ): string => `// One ${feature.camel} rendered on its own — the list's \`item\` shown outside a list, so a
 // detail route and a search result render the identical markup.
 
-import { t } from '@ultimat3/i18n';
+${catalogImport(module)}
 import type { ${feature.pascal} } from '../entity';
 import styles from '../ui.module.scss';
 
@@ -114,7 +133,7 @@ export interface ${feature.pascal}CardProps {
   readonly row: ${feature.pascal};
 }
 
-export function ${feature.pascal}Card(props: ${feature.pascal}CardProps) {
+export function ${feature.pascal}Card(props: ${feature.pascal}CardProps) {${translatorBinding(module)}
   return (
     <article class={styles.item}>
       <h3>{props.row.title}</h3>
@@ -124,39 +143,6 @@ export function ${feature.pascal}Card(props: ${feature.pascal}CardProps) {
 }
 `;
 
-const formSource = (
-  feature: NameSet,
-): string => `// Presentation only: the mutator this submits to owns validation server-side, so this form
-// never re-implements the invariant — a blank title fails at the boundary, not in the DOM.
-
-import { t } from '@ultimat3/i18n';
-import { createSignal } from 'solid-js';
-import styles from '../ui.module.scss';
-
-export interface ${feature.pascal}FormProps {
-  readonly onSubmit: (title: string) => void;
-}
-
-export function ${feature.pascal}Form(props: ${feature.pascal}FormProps) {
-  const [title, setTitle] = createSignal('');
-  return (
-    <form
-      class={styles.item}
-      onSubmit={(event) => {
-        event.preventDefault();
-        props.onSubmit(title());
-      }}
-    >
-      <label>
-        {t('app.${feature.kebab}.titleLabel')}
-        <input value={title()} onInput={(event) => setTitle(event.currentTarget.value)} />
-      </label>
-      <button type="submit">{t('app.${feature.kebab}.submit')}</button>
-    </form>
-  );
-}
-`;
-
 // `admin.<feature>.title` is always here, `--admin` or not: `defineAdmin()` resolves that key the
 // moment anyone writes the override, and a missing key renders ⟦key⟧ and fails the i18n gate,
 // while an unused key is only ever reported (`auditCatalogs` fails on `missing`, never `unused`).
@@ -166,6 +152,8 @@ const catalogSource = (feature: NameSet): string =>
     [`app.${feature.kebab}.updated`]: 'Last updated',
     [`app.${feature.kebab}.titleLabel`]: 'Title',
     [`app.${feature.kebab}.submit`]: 'Save',
+    [`app.${feature.kebab}.saved`]: 'Saved',
+    [`app.${feature.kebab}.retry`]: 'Try again',
     [`admin.${feature.kebab}.title`]: pascal(feature.plural),
   });
 
@@ -174,12 +162,21 @@ export interface ResourceOptions extends FeatureTarget {
   readonly admin?: boolean;
   /** Every locale the feature's catalog ships for. Defaults to `['en']`. */
   readonly locales?: readonly string[];
+  /**
+   * The app's own catalog module — `@<app>/i18n`, read off `packages/i18n/package.json` by
+   * `resolveCatalogModule`. Absent only for an app that ships no such package.
+   */
+  readonly catalogModule?: string;
 }
 
 export function resourceFiles(rawName: string, target: ResourceOptions): readonly GeneratedFile[] {
   const feature = names(rawName);
   const slice: FeatureTarget = { surfaceDir: target.surfaceDir, feature: feature.kebab };
   const dir = `${slice.surfaceDir}/${slice.feature}`;
+  // The page this same call writes, from the function that decides where a route goes — the island
+  // specifier is resolved against it, so re-deriving the path here would be two answers to one
+  // question and only one of them reaches `routeFiles`.
+  const pageDir = routeDir('app', feature.pluralKebab);
   const locales = resolveLocales(target.locales);
   return [
     ...entityFiles(rawName, slice),
@@ -190,18 +187,30 @@ export function resourceFiles(rawName: string, target: ResourceOptions): readonl
     ...jobFiles(`reindex-${feature.kebab}`, slice),
     { path: `${dir}/service.ts`, contents: serviceSource(feature) },
     { path: `${dir}/service.test.ts`, contents: serviceTest(feature) },
-    { path: `${dir}/ui.tsx`, contents: uiSource(feature) },
+    { path: `${dir}/ui.tsx`, contents: uiSource(feature, target.catalogModule) },
     { path: `${dir}/ui.module.scss`, contents: uiStyle() },
-    { path: `${dir}/ui/${feature.kebab}-card.tsx`, contents: cardSource(feature) },
-    { path: `${dir}/ui/${feature.kebab}-form.tsx`, contents: formSource(feature) },
+    {
+      path: `${dir}/ui/${feature.kebab}-card.tsx`,
+      contents: cardSource(feature, target.catalogModule),
+    },
+    ...formIslandFiles(feature, dir, pageDir),
     ...locales.map((locale) => ({
       path: catalogPath(locale),
       contents: catalogSource(feature),
       merge: 'json' as const,
     })),
-    // Always an app route: a slice ships a live query, a form and actions, and `generate()`
+    // Always an app route: a slice ships a live query, a form island and actions, and `generate()`
     // refuses `--surface site` for a resource rather than emit them behind a 0kb budget.
-    ...routeFiles(feature.pluralKebab, { surface: 'app', locales }),
+    //
+    // `catalogModule` travels with it. It did not, so the page a RESOURCE writes imported `t` from
+    // `@ultimat3/i18n` while the components beside it imported `useT` from the app's own catalog
+    // module — one command, two idioms, and the framework-import one is issue #249's: it renders
+    // strings while depending on nothing that registers them.
+    ...routeFiles(feature.pluralKebab, {
+      surface: 'app',
+      locales,
+      ...(target.catalogModule === undefined ? {} : { catalogModule: target.catalogModule }),
+    }),
     ...(target.admin === true ? adminFiles(rawName, slice) : []),
   ];
 }

package/src/templates/route.ts

@@ -19,6 +19,14 @@ export type Surface = 'site' | 'app';
  * that was absent from `x routes`, from the manifest and from `budgets`. Ship the mode that works.
  */
 const RENDER: Record<Surface, string> = { site: 'isr', app: 'ssr' };
+/**
+ * `app` is `'visible'` on a page the generator writes with no island, and that is not an oversight.
+ * A declared strategy costs nothing when there is nothing to hydrate — `hydrateRuntime` is emitted
+ * per island DIRECTIVE and answers `''` for a page with none (`packages/render/src/hydrate.ts`), so
+ * `x routes` reads `visible` while the document ships 0 bytes. What it buys is that adding the
+ * first island is one edit: a declared `'never'` beside an island is `X_ISLAND_NOT_HYDRATED`, which
+ * `defineRoute` refuses on purpose, so the scaffold would break at the moment it is first used.
+ */
 const HYDRATE: Record<Surface, string> = { site: 'never', app: 'visible' };
 const OFFLINE: Record<Surface, string> = { site: 'precache', app: 'runtime' };
 /**
@@ -66,10 +74,35 @@ export const routeParams = (path: string): readonly string[] =>
     return name === undefined ? [] : [name];
   });
 
-const routeDir = (surface: Surface, path: string): string =>
+/**
+ * Where the page lands. Exported because an island's `src` is resolved relative to the PAGE, and
+ * only this function knows where `x g resource`'s page went — a second copy of the formula in the
+ * resource generator is how the specifier it prints stops matching the file it writes.
+ */
+export const routeDir = (surface: Surface, path: string): string =>
   `apps/web/${surface}/${segmentsOf(path).join('/')}`;
 
-const pageSource = (surface: Surface, path: string): string => {
+/**
+ * How the generated page reaches a string, and it is the whole reason this generator takes an app
+ * module at all. `useT()` comes from the app's own catalog module — the one that calls
+ * `defineCatalogs()` — so a page that renders a string DEPENDS on the module that registers them.
+ * Reaching straight for `t` in `@ultimat3/i18n` renders strings while depending on nothing, which
+ * is how a shipped app served `⟦app.play.title⟧` on every page with a green gate (issue #249), and
+ * this generator is where that idiom came from.
+ *
+ * An app with no catalog module keeps the framework import: emitting one that cannot resolve would
+ * trade a wrong idiom for a file that does not compile.
+ */
+const catalogImport = (module: string | undefined): string =>
+  module === undefined
+    ? "import { t } from '@ultimat3/i18n';"
+    : `import { useT } from '${module}';`;
+
+/** `useT()` is per render, so the body binds it; `meta` takes the router's own `t`. */
+const translatorBinding = (module: string | undefined): string =>
+  module === undefined ? '' : '\n  const t = useT();\n';
+
+const pageSource = (surface: Surface, path: string, module: string | undefined): string => {
   const name = pascal(
     path
       .split('/')
@@ -79,7 +112,7 @@ const pageSource = (surface: Surface, path: string): string => {
   return `// Route: /${path} on the ${surface} surface. Config first: render mode, offline
 // strategy and budget are declarations, not runtime choices.
 
-import { t } from '@ultimat3/i18n';
+${catalogImport(module)}
 import { defineRoute } from '@ultimat3/render';
 import styles from './page.module.scss';
 
@@ -88,13 +121,13 @@ export const config = defineRoute({
   hydrate: '${HYDRATE[surface]}',
   offline: '${OFFLINE[surface]}',
   budget: ${budgetLiteral(surface)},
-  meta: () => ({
+  meta: ({ t }) => ({
     title: t('${titleKey(path)}'),
     description: t('${titleKey(path).replace('.title', '.description')}'),
   }),
 });
 
-export function ${name}Page() {
+export function ${name}Page() {${translatorBinding(module)}
   return (
     <main class={styles.page}>
       <h1>{t('${titleKey(path)}')}</h1>
@@ -202,6 +235,12 @@ export interface RouteOptions {
   readonly surface: Surface;
   /** Every locale the catalog entry ships for. Defaults to `['en']` — an app narrows or grows it. */
   readonly locales?: readonly string[];
+  /**
+   * The app's own catalog module — `@<app>/i18n`, read off `packages/i18n/package.json` by
+   * `resolveCatalogModule`. Absent for an app that ships no such package, and only then does the
+   * generated page fall back to importing `t` from `@ultimat3/i18n`.
+   */
+  readonly catalogModule?: string;
 }
 
 export function routeFiles(rawPath: string, options: RouteOptions): readonly GeneratedFile[] {
@@ -209,7 +248,7 @@ export function routeFiles(rawPath: string, options: RouteOptions): readonly Gen
   const dir = routeDir(options.surface, path);
   const locales = resolveLocales(options.locales);
   return [
-    { path: `${dir}/page.tsx`, contents: pageSource(options.surface, path) },
+    { path: `${dir}/page.tsx`, contents: pageSource(options.surface, path, options.catalogModule) },
     { path: `${dir}/page.module.scss`, contents: styleSource() },
     { path: `${dir}/page.test.ts`, contents: routeTest(options.surface, path) },
     { path: `${dir}/page.e2e.test.ts`, contents: routeE2eTest(path) },

package/src/templates/scaffold-app.ts

@@ -7,6 +7,10 @@ import { apiFiles } from './scaffold-api';
 import { icon } from './scaffold-icon';
 import { rolesFiles } from './scaffold-roles';
 
+// The one dependency this manifest names, and it is not decoration: every page below reads its
+// strings through `@<app>/i18n`'s `useT()`, so the surface that renders a string DEPENDS on the
+// module that registers the catalogs. An undeclared workspace dependency resolves through the root
+// symlink and then breaks the day the app is built anywhere else.
 const webPackage = (app: NameSet): string => `{
   "name": "@${app.kebab}/web",
   "version": "0.0.0",
@@ -18,6 +22,9 @@ const webPackage = (app: NameSet): string => `{
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@${app.kebab}/i18n": "0.0.0"
   }
 }
 `;
@@ -34,7 +41,12 @@ const tsconfig = (): string => `{
 const sitePage = (
   app: NameSet,
 ): string => `// The landing page. site/ is 0kb JS: static render, hydrate never, no framework script tag.
-import { t } from '@ultimat3/i18n';
+//
+// Strings come from \`useT()\` — this app's own catalog module — and never from
+// \`t\` in @ultimat3/i18n. That import is what puts the module holding \`defineCatalogs()\` in
+// this page's graph, so rendering a string is what registers the catalogs. A page that reached
+// past it shipped every string as \`\u27e6key\u27e7\` with \`x verify\` green (issue #249).
+import { useT } from '@${app.kebab}/i18n';
 import { defineRoute } from '@ultimat3/render';
 import styles from './page.module.scss';
 
@@ -43,13 +55,17 @@ export const config = defineRoute({
   hydrate: 'never',
   offline: 'precache',
   budget: { js: '0kb' },
-  meta: () => ({
+  // \`t\` is handed to \`meta\` by the router — one translator per render, resolved against the
+  // request's locale before the head is built.
+  meta: ({ t }) => ({
     title: t('site.home.title'),
     description: t('site.home.description'),
   }),
 });
 
 export function HomePage() {
+  const t = useT();
+
   return (
     <main class={styles.hero}>
       <h1>{t('site.home.title')}</h1>
@@ -103,11 +119,13 @@ unitTest('the landing page ships zero JS and declares metadata', async () => {
 });
 `;
 
-const dashboardPage =
-  (): string => `// The authed dashboard. app/ streams: a static shell is flushed instantly and the holes arrive
+const dashboardPage = (
+  app: NameSet,
+): string => `// The authed dashboard. app/ streams: a static shell is flushed instantly and the holes arrive
 // as their data resolves.
 
-import { t } from '@ultimat3/i18n';
+// \`useT()\`, not \`t\` from @ultimat3/i18n — see apps/web/site/page.tsx for why.
+import { useT } from '@${app.kebab}/i18n';
 import { defineRoute } from '@ultimat3/render';
 import styles from './page.module.scss';
 
@@ -118,15 +136,22 @@ export const config = defineRoute({
   // therefore failed x routes with X_ROUTE_MODE_INVALID on the first run, printing a fix nobody
   // could follow. Ship the mode that works. Async data needs no boundary: await it in the page.
   render: 'ssr',
+  // Stated with no island on the page, deliberately and for free — \`apps/admin/app/admin/page.tsx\`
+  // carries the reason.
   hydrate: 'visible',
   offline: 'runtime',
   // Auth is a policy, never a route-local flag: one authz system, evaluated everywhere.
   policy: { permission: 'dashboard:read' },
   budget: { js: '60kb' },
-  meta: () => ({ title: t('app.dashboard.title'), description: t('app.dashboard.description') }),
+  meta: ({ t }) => ({
+    title: t('app.dashboard.title'),
+    description: t('app.dashboard.description'),
+  }),
 });
 
 export function DashboardPage() {
+  const t = useT();
+
   return (
     <section class={styles.panel}>
       <h1>{t('app.dashboard.title')}</h1>
@@ -157,14 +182,18 @@ unitTest('the dashboard renders on the server, is gated, and has an offline stra
 });
 `;
 
-const offlineFallback =
-  (): string => `// The offline fallback. Every app/ route with offline: 'runtime' falls back here, so a train
+const offlineFallback = (
+  app: NameSet,
+): string => `// The offline fallback. Every app/ route with offline: 'runtime' falls back here, so a train
 // tunnel shows the product's own shell instead of the browser's error page.
 
-import { t } from '@ultimat3/i18n';
+// \`useT()\`, not \`t\` from @ultimat3/i18n — see apps/web/site/page.tsx for why.
+import { useT } from '@${app.kebab}/i18n';
 import styles from './offline.module.scss';
 
 export function OfflineFallback() {
+  const t = useT();
+
   return (
     <main class={styles.offline}>
       <h1>{t('app.offline.title')}</h1>
@@ -267,6 +296,8 @@ unitTest('holds answers from the role map, and an anonymous actor holds nothing'
 });
 `;
 
+// Same one dependency as `apps/web`, and for the same reason: `app/admin/page.tsx` reads its
+// strings through `@<app>/i18n`'s `useT()`.
 const adminPackage = (app: NameSet): string => `{
   "name": "@${app.kebab}/admin",
   "version": "0.0.0",
@@ -278,28 +309,42 @@ const adminPackage = (app: NameSet): string => `{
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@${app.kebab}/i18n": "0.0.0"
   }
 }
 `;
 
-const adminPage =
-  (): string => `// The generated admin dashboard. It ships an MCP surface over the app's own actions, so the
+const adminPage = (
+  app: NameSet,
+): string => `// The generated admin dashboard. It ships an MCP surface over the app's own actions, so the
 // user's agents can drive the user's product with the user's permissions.
 
-import { t } from '@ultimat3/i18n';
+// \`useT()\`, not \`t\` from @ultimat3/i18n — see apps/web/site/page.tsx for why.
+import { useT } from '@${app.kebab}/i18n';
 import { defineRoute } from '@ultimat3/render';
 
 export const config = defineRoute({
-  render: 'spa',
+  render: 'ssr',
+  // Stated on a page whose body is one \`<h1>\`, and it costs nothing: the hydration runtime is
+  // emitted per island DIRECTIVE, so \`hydrateRuntime([])\` is \`''\` and this document ships 0 bytes
+  // (\`packages/render/src/hydrate.ts\`). It buys the first island being ONE file's edit —
+  // \`hydrate: 'never'\` beside an island is \`X_ISLAND_NOT_HYDRATED\`, which defineRoute refuses.
   hydrate: 'idle',
   offline: 'network-only',
-  // A spa renders no data, so the shell itself must be gated — @ultimat3/render requires it.
+  // Behind auth, so the mode has to render per request: \`ssr\` and \`stream\` both do, and both take
+  // a \`policy\`. \`static\` and \`isr\` refuse one outright — a file on disk has no actor to decide
+  // against, and an ISR document is cached per URL, so the first actor's HTML would be served to
+  // every later one who passes the same policy.
   policy: { permission: 'admin:read' },
   budget: { js: '120kb' },
-  meta: () => ({ title: t('admin.home.title'), description: t('admin.home.description') }),
+  meta: ({ t }) => ({ title: t('admin.home.title'), description: t('admin.home.description') }),
 });
 
 export function AdminHome() {
+  const t = useT();
+
   return <h1>{t('admin.home.title')}</h1>;
 }
 `;
@@ -357,6 +402,12 @@ const prerender =
 // whatever its mode, so \`x verify\`'s \`budgets\` step has a number for it. \`unmeasured\` is the list
 // this build could not render — each one is an X_BUDGET_UNMEASURED at the gate, and this is where
 // the reason is.
+//
+// It writes the whole of \`pages\` and \`skipped\`, never a COUNT of either. A count is what let a
+// partial artifact read as a complete one: someone pointed a screenshot tool at \`.x/static\` and
+// filed "the island did not mount" against a route that had never been emitted (issue #242). Each
+// skipped route carries its own \`reason\` and \`why\`, and \`report\` is where the same inventory
+// landed on disk — which is what \`x build --target static --json\` reads back.
 
 import { join } from 'node:path';
 import { prerenderSite } from '@ultimat3/cli';
@@ -373,7 +424,7 @@ const origin = Bun.env.SITE_ORIGIN;
 if (import.meta.main) {
   const report = await prerenderSite({ root, out, ...(origin === undefined ? {} : { origin }) });
   await Bun.stdout.write(
-    \`\${JSON.stringify({ ok: true, out: report.out, pages: report.pages.length, skipped: report.skipped, unmeasured: report.unmeasured })}\\n\`,
+    \`\${JSON.stringify({ ok: true, out: report.out, emitted: report.pages, skipped: report.skipped, unmeasured: report.unmeasured, report: report.report })}\\n\`,
   );
 }
 `;
@@ -402,10 +453,10 @@ export function appFiles(app: NameSet, example: boolean): readonly GeneratedFile
     { path: 'apps/web/site/page.tsx', contents: sitePage(app) },
     { path: 'apps/web/site/page.module.scss', contents: siteStyle() },
     { path: 'apps/web/site/page.test.ts', contents: sitePageTest() },
-    { path: 'apps/web/app/dashboard/page.tsx', contents: dashboardPage() },
+    { path: 'apps/web/app/dashboard/page.tsx', contents: dashboardPage(app) },
     { path: 'apps/web/app/dashboard/page.module.scss', contents: dashboardStyle() },
     { path: 'apps/web/app/dashboard/page.test.ts', contents: dashboardTest() },
-    { path: 'apps/web/app/offline.tsx', contents: offlineFallback() },
+    { path: 'apps/web/app/offline.tsx', contents: offlineFallback(app) },
     { path: 'apps/web/app/offline.module.scss', contents: offlineStyle() },
     // The third surface, and the one call that registers what the app declares — `scaffold-api.ts`.
     ...apiFiles(example),
@@ -425,7 +476,7 @@ export function appFiles(app: NameSet, example: boolean): readonly GeneratedFile
     // `apps/web/site/page.tsx` — `x dev` loads both surfaces into one route table and the
     // scaffolded app failed its own `x routes` with X_ROUTE_DUPLICATE. `/admin` also matches
     // @ultimat3/admin's own `basePath` default, so the two agree instead of merely not clashing.
-    { path: 'apps/admin/app/admin/page.tsx', contents: adminPage() },
+    { path: 'apps/admin/app/admin/page.tsx', contents: adminPage(app) },
     { path: 'apps/mobile/README.md', contents: placeholder('mobile', app) },
     { path: 'apps/desktop/README.md', contents: placeholder('desktop', app) },
   ];

package/src/templates/scaffold-container.ts

@@ -21,7 +21,7 @@ const dockerfile = (
 # syntax=docker/dockerfile:1
 
 # ---------- deps: runtime dependencies only, cached on the workspace manifests ----------
-FROM oven/bun:1.3-alpine AS deps
+FROM oven/bun:1.4-alpine AS deps
 WORKDIR /app
 COPY package.json bun.lock ./
 # The workspace members' manifests are what \`bun install\` resolves against; their sources are not.
@@ -34,7 +34,7 @@ RUN bun install --frozen-lockfile --production
 # before it ever calls \`docker build\`. Re-running typecheck and lint here would need the
 # devDependencies the \`--production\` install above deliberately leaves out — which is exactly how
 # a build stage came to run \`tsc\` and \`biome\` against a tree that had neither.
-FROM oven/bun:1.3-alpine AS runtime
+FROM oven/bun:1.4-alpine AS runtime
 WORKDIR /app
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .