gemi 0.59.0 → 0.60.0

package/skills/gemi-react-best-practices/rules/routing-routers-are-classes.md

@@ -0,0 +1,55 @@
+---
+title: Routes Are Declared on Router Classes, Not by File Location
+impact: HIGH
+impactDescription: the only place a URL is defined
+tags: routing, structure, views
+---
+
+## Routes Are Declared on Router Classes, Not by File Location
+
+Routing is **class-based**. A `ViewRouter` or `ApiRouter` subclass carries a `routes`
+object mapping a path to a handler, and routers nest by assigning one as a route
+value. Putting a file in `app/views` registers nothing — **the view file name has no
+relation to the URL**, and the mapping in `app/http/routes/view.ts` is the only thing
+that makes a page reachable.
+
+**Incorrect (creating the file and expecting a URL):**
+
+```tsx
+// app/views/customer/Billing.tsx — reachable at… nothing.
+export default function Billing() { /* … */ }
+```
+
+**Correct (register it, and bind its server data):**
+
+```ts
+// app/http/routes/view.ts
+class CustomerRouter extends ViewRouter {
+  middlewares = ["cache:private,0,no-store", "auth"];
+  routes = {
+    "/billing": this.view("customer/Billing", [BillingController, "view"]),
+  };
+}
+```
+
+The pieces worth knowing:
+
+- **`this.view(name, handler?)`** — the handler is an inline callback or a
+  `[Controller, "method"]` tuple; its return value becomes the component's props.
+- **`this.layout(name, handler?, routes)`** — nests a layout around child routes.
+  A layout handler **does not re-run** while navigating within the same layout unless
+  it is marked `.alwaysRun()`.
+- **`:param`** dynamic, **`:param?`** optional, **`(group)/`** groups routes for
+  shared middleware or a layout **without adding a URL segment**.
+- **`this.redirect(() => ({ destination }))`** for a static redirect.
+
+On the API side: `this.get/post/put/patch/delete(Controller, "method")`,
+`this.file(...)`, `this.stream(...)` (handles 206/416 and `Content-Range` for
+range requests), `this.proxy(...)`, and an object of lowercase method keys to bind
+several verbs to one path.
+
+**A view component must be a default export; a controller must be a named export.**
+The router imports each by that convention.
+
+Reference: `app/http/routes/view.ts`, `app/http/routes/api.ts`
+<https://nstfkc.github.io/gemi/routing.md>

package/skills/gemi-react-best-practices/rules/service-lazy-not-module-scope.md

@@ -0,0 +1,63 @@
+---
+title: Construct Clients Lazily, Never at Module Scope
+impact: HIGH
+impactDescription: keeps boot fast and command discovery working
+tags: service, boot, module-scope, commands
+---
+
+## Construct Clients Lazily, Never at Module Scope
+
+Work at module scope runs whenever the module is *imported*, which is not the same as
+when it is *used*. Three places in a gemi app punish that:
+
+1. **Command discovery imports every file under `app/commands` just to list them.**
+   A `new Stripe(key)` beside the handler throws on an empty key during
+   `gemi run` — with no command actually invoked.
+2. **Service `boot()` runs on every application start**, including per-test and
+   per-CLI-command. Validate settings there; open connections lazily.
+3. **Ports are installed at boot, after every module in the graph has evaluated**, so
+   reading one at module scope gets `undefined`.
+
+**Incorrect (constructed on import; `boot()` opens a connection):**
+
+```ts
+const stripe = new Stripe(process.env.STRIPE_KEY!);   // throws at import time
+
+export class SearchIndex extends Service {
+  static token = "searchIndex";
+  async boot() {
+    this.client = await Client.connect(process.env.SEARCH_URL!); // every start
+  }
+}
+```
+
+**Correct (validate at boot, connect on first use, construct in the handler):**
+
+```ts
+export class SearchIndex extends Service {
+  static token = "searchIndex";
+  url = process.env.SEARCH_URL;
+  private ready?: Promise<Client>;
+
+  async boot() {
+    if (!this.url) throw new Error("SEARCH_URL is not set");
+  }
+
+  private connect() {
+    return (this.ready ??= Client.connect(this.url!));
+  }
+}
+
+export default defineCommand("sync-prices").handle(async ({ line }) => {
+  const stripe = new Stripe(process.env.STRIPE_KEY!);   // inside the handler
+});
+```
+
+**`Service.inject()` must not be called at module top level either** — it throws
+because the kernel has not booted. Inject as a constructor default
+(`constructor(private billing = Billing.inject())`), which resolves per request and
+lets a test pass a double without touching the container.
+
+**Read a runtime port inside a function or behind a getter**, never at module scope.
+
+Reference: <https://nstfkc.github.io/gemi/services.md>

package/skills/gemi-react-best-practices/rules/service-queue-is-in-memory.md

@@ -0,0 +1,52 @@
+---
+title: The Queue Is In-Process and In-Memory — Do Not Trust It With Durable Work
+impact: HIGH
+impactDescription: enqueued work is lost on restart
+tags: service, jobs, queue, durability
+---
+
+## The Queue Is In-Process and In-Memory — Do Not Trust It With Durable Work
+
+Jobs live in the server process's memory. **Enqueued jobs do not survive a restart**,
+and there is no cross-machine queue — a job dispatched on one instance runs on that
+instance or not at all. Use jobs for best-effort work: warming a cache, sending a
+non-critical email, kicking off media processing that the user can retry.
+
+Anything that must not be lost needs a durable record: write the row first, then let
+the job (or a cron sweep) act on it, so a restart leaves work to pick up rather than
+a gap.
+
+**Incorrect (the only record of the charge lives in the queue):**
+
+```ts
+async store(req: HttpRequest) {
+  const order = await Order.create({ data });
+  SettleOrderJob.dispatch({ orderId: order.publicId }); // lost on deploy
+  return { order };
+}
+```
+
+**Correct (durable state first; the job is an accelerator):**
+
+```ts
+async store(req: HttpRequest) {
+  const order = await Order.create({ data: { ...data, settlementStatus: "pending" } });
+  SettleOrderJob.dispatch({ orderId: order.publicId });
+  return { order };
+}
+// A cron sweeps `settlementStatus: "pending"` rows, so a lost dispatch self-heals.
+```
+
+**Two deployment-shaped constraints that follow:**
+
+- **The `queue` and `schedule` config slices declare their `jobs` lists
+  explicitly, and must keep doing so.** Discovery is a *runtime* filesystem walk, and
+  the release image ships only `dist/` — there is no `app/jobs` or `app/cron` on disk
+  in production. Discovery there warns once and registers nothing, so every job and
+  cron would stop running while dev and CI stayed green. Note `jobs: []` is
+  *present* and disables everything; omitting the key is what enables discovery.
+- **A command dispatching a Job may exit before it runs.** The queue runs in-process
+  and the cron scheduler does not start under `gemi run` — do that work inline in the
+  command instead.
+
+Reference: <https://nstfkc.github.io/gemi/jobs-and-queues.md>

package/skills/gemi-react-best-practices/rules/service-static-token-and-name.md

@@ -0,0 +1,52 @@
+---
+title: Services and Jobs Need a Static String Identifier
+impact: HIGH
+impactDescription: works in dev, silently breaks in the production build
+tags: service, jobs, minification, production
+---
+
+## Services and Jobs Need a Static String Identifier
+
+A `Service` needs `static token`; a `Job` needs `static name`. Both are string
+literals because **minification renames classes in the production build** — the
+container key and the queue's dispatch name must survive that rename. This is a
+class of bug that cannot reproduce locally: dev is unminified, so everything works
+until it is deployed.
+
+**Incorrect (relies on the class name surviving the build):**
+
+```ts
+export class ProcessVideoJob extends Job {
+  async run(params: Params) { /* … */ }
+}
+```
+
+**Correct:**
+
+```ts
+export class ProcessVideoJob extends Job {
+  static name = "ProcessVideoJob";
+  maxAttempts = 3;
+
+  async run(params: Params) { /* … */ }
+  onFail(error: Error, params: Params) { /* … */ }
+  onDeadletter(error: Error, params: Params) { /* … */ }
+}
+
+export class Billing extends Service {
+  static token = "Billing";
+}
+```
+
+- **Tokens must be unique.** Two jobs claiming one name: the framework refuses the
+  second with a line on stderr rather than silently dropping it — rename one.
+- **`maxAttempts` defaults to 3.** `run` throwing calls `onFail` and requeues;
+  the final failure calls `onDeadletter` and drops the job.
+- **`worker: true`** runs the job in a separate Worker thread, for CPU-bound work.
+- **Dispatch is fire-and-forget** — `Job.dispatch(payload)` returns `void`. Pass only
+  serializable data, never a class instance or a function.
+
+**Register services explicitly on `Kernel.services`, and note that boot order is
+load-bearing** — a service listed first boots before those after it.
+
+<https://nstfkc.github.io/gemi/jobs-and-queues.md>

package/skills/gemi-react-best-practices/rules/structure-discovered-vs-registered.md

@@ -0,0 +1,71 @@
+---
+title: Know Which Directories Are Discovered and Which Need Declaring
+impact: HIGH
+impactDescription: the difference between code that runs and code that silently never does
+tags: structure, discovery, kernel, registration
+---
+
+## Know Which Directories Are Discovered and Which Need Declaring
+
+`app/` has two kinds of directory, and confusing them produces the same symptom
+either way: code that looks correct, imports cleanly, typechecks, and never runs.
+
+**Discovered — writing the file *is* the registration:**
+
+| Directory | Base class | Read at |
+|---|---|---|
+| `app/cron/` | `CronJob` | boot |
+| `app/jobs/` | `Job` | boot |
+| `app/listeners/` | `Listener` | boot |
+| `app/commands/` | `defineCommand` chains | `gemi run` only |
+
+Nothing anywhere names these. Adding a `Job` subclass under `app/jobs/` registers
+it; there is no list to append to, and appending to one you invented does nothing.
+
+`app/listeners/` is the one the scaffold does not create — its absence is not an
+error, it means the app has no listeners yet.
+
+**Declared — the file is not enough:**
+
+- **Models** are declared on the Kernel. A model class under `app/models/` that
+  the Kernel's `models` does not reach is not registered, and `gemi check models`
+  exists to report exactly that gap for policied models.
+- **Routers** are registered explicitly — `app/http/routes/view.ts` and `api.ts`
+  are the roots, and a new router is reached by being mounted from one of them.
+- **Config slices** under `app/config/` are named by the Kernel's `config`.
+- **Service providers** under `app/providers/` are named by the Kernel's
+  `providers`.
+
+**Incorrect (a job that never runs, because a hand-rolled list is not the mechanism):**
+
+```ts
+// app/jobs/index.ts — invented; nothing reads this
+export const jobs = [SendWelcomeEmail, ReindexProducts];
+```
+
+**Correct (the file is the registration):**
+
+```ts
+// app/jobs/SendWelcomeEmail.ts
+export class SendWelcomeEmail extends Job {
+  static token = "SendWelcomeEmail";
+  // …
+}
+```
+
+**Incorrect (a model that typechecks and is never registered):**
+
+```ts
+// app/models/Invoice.ts — written, but not reachable from the Kernel's `models`
+export class Invoice extends Model {}
+```
+
+The four discovered directories have a cost worth knowing: **discovery imports
+every file it walks**, because a class does not exist until its module has run. A
+file in one of them that does work at import time does that work at boot. Keep
+them to declarations — see `service-lazy-not-module-scope`.
+
+The discovered directories can also be declared explicitly in their config slice
+(`schedule`, `queue`, `events`, `command`), which turns the walk off and uses the
+list verbatim. An empty array is a declaration too, and means "this app has none"
+— not "fall back to walking".

package/skills/gemi-react-best-practices/rules/structure-do-not-reinvent-the-framework.md

@@ -0,0 +1,58 @@
+---
+title: Do Not Build Structure the Framework Already Has
+impact: HIGH
+impactDescription: a parallel structure is one the framework's own tooling cannot see
+tags: structure, container, services, conventions
+---
+
+## Do Not Build Structure the Framework Already Has
+
+The reflex when a codebase needs somewhere to put shared code is to add `lib/`,
+`utils/`, or a hand-rolled registry. In a gemi app most of those already exist
+with a name, and the cost of the parallel one is not duplication — it is that the
+framework's own machinery cannot see it.
+
+| The reflex | What gemi already has |
+|---|---|
+| A `lib/` of shared classes with I/O | `app/services/`, classes extending `Service`, resolved from the container |
+| A module-scope singleton client | A `Service` with a `static token`, injected where needed |
+| A hand-rolled service locator or DI map | The container; `app/providers/` binds into it |
+| A custom router, or routing by file path | Router classes under `app/http/routes/` |
+| Ad-hoc `if (!req.body.name)` checks | An `HttpRequest` subclass under `app/http/requests/` |
+| A `constants.ts` of env reads | A config slice under `app/config/` |
+| A `scripts/` folder run with `bun x.ts` | `app/commands/`, run by `gemi run` |
+| A barrel re-exporting a package's modules | Deep imports — see `bundle-deep-imports` |
+
+**Incorrect (a registry the framework cannot see):**
+
+```ts
+// app/lib/services.ts — invented
+export const billing = new Billing(process.env.STRIPE_KEY!);
+```
+
+Constructed at module scope, so it runs whenever anything imports the file —
+including a discovery walk that imports every file in a directory. Nothing can
+rebind it in a test, and nothing resolves it by token.
+
+**Correct:**
+
+```ts
+// app/services/Billing.ts
+export class Billing extends Service {
+  static token = "Billing";
+  // Constructed lazily by the container, rebindable in a test.
+}
+```
+
+Two things follow from this that are easy to get backwards:
+
+- **A view's file path is not its URL.** `app/views/` is organised however you
+  like; routing is declared on router classes. Moving a view does not change a
+  route, and creating one under a path that "looks like" a URL registers nothing.
+  See `routing-routers-are-classes`.
+- **`app/models/generated/` is output.** Editing it is editing a build artifact —
+  the change disappears on the next generate.
+
+When a rule here and an existing pattern in your app disagree, check the app's
+`CLAUDE.md` and git history before "fixing" it: the app may have a reason, and
+ground rule 2 says the app wins.

package/skills/gemi-react-best-practices/rules/testing-assert-behaviour-over-markup.md

@@ -0,0 +1,54 @@
+---
+title: Mount and Query the DOM — Do Not Scrape Rendered Markup
+impact: MEDIUM-HIGH
+impactDescription: catches real regressions instead of string drift
+tags: testing, testing-library, house-style
+---
+
+## Mount and Query the DOM — Do Not Scrape Rendered Markup
+
+Asserting on `renderToStaticMarkup` / `renderToString` output — substring matches,
+regex scrapes for `href=`, index arithmetic to prove ordering — tests the markup
+rather than the component. It passes when the component is broken and fails when a
+class name changes.
+
+**Incorrect:**
+
+```tsx
+const html = renderToStaticMarkup(<ProductList products={products} />);
+expect(html).toContain("Chair");
+expect(html.indexOf("Chair")).toBeLessThan(html.indexOf("Desk"));
+expect(html).toMatch(/href="\/app\/abc\/products\/1"/);
+```
+
+**Correct:**
+
+```tsx
+render(<Page {...}><ProductList /></Page>);
+
+expect(screen.getByRole("link", { name: "Chair" })).toHaveAttribute(
+  "href", "/app/abc/products/1",
+);
+expect(
+  screen.getByText("Chair").compareDocumentPosition(screen.getByText("Desk")),
+).toBe(Node.DOCUMENT_POSITION_FOLLOWING);
+```
+
+Use `getByRole` / `getByLabelText`, `compareDocumentPosition` for order, and
+`label[for]` for input association. **The one exception is a test whose SUBJECT is
+the server payload** — e.g. guarding that a virtualised grid does not ship an empty
+shell. Say so in the file when you take it.
+
+**Assert what goes over the wire, not how a query was configured.** Checking that
+`lazy` or `refreshInterval` was passed tests the arguments; it cannot tell a working
+pager from one that never fetched. A non-lazy query is proved by a request arriving
+on mount, a lazy one by no request arriving until something asks.
+
+**Mock HTTP with MSW, not by replacing `globalThis.fetch`.** `setupServer` +
+`server.listen({ onUnhandledRequest: "error" })` makes an undeclared request fail
+instead of silently resolving, and lets a case assert against the real `Request` —
+resolved URL, method, headers, parsed body.
+
+**Make a stub load-bearing.** A test that removes `crypto.randomUUID` to reach a
+fallback, then asserts a shape both branches satisfy, passes either way. Assert the
+exact value.

package/skills/gemi-react-best-practices/rules/testing-match-the-suite.md

@@ -0,0 +1,57 @@
+---
+title: Match the Suite You Are In
+impact: MEDIUM
+impactDescription: a test the runner never selects is a test that does not exist
+tags: testing, runner, conventions
+---
+
+## Match the Suite You Are In
+
+Before adding a test, read the neighbours and the runner config. Copy the runner, the
+import source, and the file-naming convention already in use in that directory. A
+test written for the wrong runner does not fail loudly — the runner simply never
+selects the file, and it sits green forever without executing.
+
+**This is the whole rule for the common case.** Everything below is the gemi-specific
+part: the two things that trip up a component test in a gemi app regardless of which
+runner you picked.
+
+**A component test needs a DOM.** gemi renders on the server, so a suite configured
+as a plain Node project has no `window`. Mounting a view there fails on the first
+DOM call, not with a useful message. Either point that suite at a DOM environment
+(`jsdom`, `happy-dom`) or put component tests in the half of the suite that has one.
+
+**A test of the server dictionary readers must drop `window` first.**
+`Dictionary.render` and `Dictionary.reference` throw in a browser-shaped environment,
+so a DOM-providing preload breaks them for the whole run. Reach for the server
+globals helper at module scope — a dictionary is often read while the test module
+evaluates, before any `beforeEach` has run.
+
+**Incorrect (a component test in the Node-only half of the suite):**
+
+```ts
+// runs, finds no document, fails on render
+import { render } from "@testing-library/react";
+import { describe, it } from "vitest";
+```
+
+**Correct (the same test where a DOM exists):**
+
+```ts
+import { render } from "@testing-library/react";
+import { describe, it } from "vitest"; // or "bun:test" — whichever this suite uses
+
+// vitest.config.ts: environment: "jsdom"
+```
+
+Two notes if your repo runs more than one runner:
+
+- **The file name is usually the selection mechanism.** `bun test` has no
+  include-pattern config, so a repo running both typically selects the bun half by a
+  path fragment (`<name>.bun.test.ts`) and excludes that same fragment from the other
+  runner's config. Renaming a file is what moves it between halves.
+- **`vi.hoisted` / `vi.mock` do not port.** They rely on Vitest's AST hoisting, which
+  `bun:test` has no equivalent for. A file using only `describe`/`it`/`expect` is an
+  import swap; a file using those needs rewriting.
+
+See also `testing-page-seeds-real-inputs` for how to mount a gemi view under test.

package/skills/gemi-react-best-practices/rules/testing-page-seeds-real-inputs.md

@@ -0,0 +1,65 @@
+---
+title: Mount With Page From gemi/testing, Never Mock gemi/client
+impact: HIGH
+impactDescription: tests the component instead of the mock
+tags: testing, gemi-testing, house-style
+---
+
+## Mount With Page From gemi/testing, Never Mock gemi/client
+
+`<Page>` supplies the inputs the framework normally provides — route params, search,
+locale, user, and the query cache — so a view mounts for real. **Mocking
+`gemi/client` is prohibited, and the rule is not scoped to component tests**: it
+binds hook and model tests the same way, and spreading the real module through
+(`...(await import("gemi/client"))`) is still mocking it.
+
+**Incorrect (asserts the mock, not the component):**
+
+```tsx
+mock.module("gemi/client", () => ({
+  useQuery: () => ({ data: [{ id: 1, name: "Chair" }] }),
+  useParams: () => ({ orgId: "abc" }),
+}));
+```
+
+**Correct (real hooks, seeded inputs):**
+
+```tsx
+import { Page } from "gemi/testing";
+
+render(
+  <Page
+    pathname="/app/:orgId/products"
+    params={{ orgId: "abc" }}
+    searchParams="?tab=recent"
+    locale="en-US"
+    user={{ id: 1 }}
+    queryData={{ "/app/:orgId/products": [{ id: 1, name: "Chair" }] }}
+    fallback={<Skeleton />}
+    errorFallback={<Failed />}
+    onNavigate={onNavigate}
+  >
+    <ProductsRoute />
+  </Page>,
+);
+```
+
+- **`queryData` keys are the path as `useQuery` writes it**, minus `/api`, with
+  `:params` resolved against the page's `params`. A seeded query renders on the first
+  pass and issues no request.
+- **Navigation is reported, not performed** — `onNavigate` receives
+  `(resolvedHref, "push" | "replace")`. To test the destination, mount a second
+  `<Page>`.
+- **Seed `fallback` and `errorFallback` and assert those** for a non-lazy query:
+  it suspends while in flight and throws on failure, so `loading`/`error` are not
+  what that path returns.
+
+**If an assertion can only be made by mocking `gemi/client`** — `prefetch` leaves no
+DOM trace, a synchronous `useMutate` throw — **drop the assertion, not the rule**, and
+say in the file why it went.
+
+**Do not mock anything else either** unless it is genuinely impossible otherwise. A
+Radix dropdown rendering nothing until it opens is an argument for opening it with
+`userEvent`, not for stubbing it.
+
+Reference: <https://nstfkc.github.io/gemi/testing.md>

package/dist/chunk-txhcx69q.js

@@ -1,6 +0,0 @@
-// @bun
-import{pa as h}from"./chunk-tkdxv6cq.js";import{createElement as x}from"react";function j(i,n){let s=Object.keys(n).sort((u,b)=>b.length-u.length).map((u)=>u.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")),r=new RegExp(s.join("|"),"g");return i.replace(r,(u)=>n[u])}async function J(i,n,s=[]){let r=[...s.map((t)=>`${i}/views/${t}.tsx`),`${i}/views/RootLayout.tsx`],u=new Set;for(let t of r){let e=n.moduleGraph.getModulesByFile(t);if(e)for(let d of e)u.add(d)}let b=[],p=[],c={};for(let t of u)if(t)for(let e of t.importedModules){if(e.file.includes("module.css"))c[e.file]=e.ssrTransformResult.map.sourcesContent.join("");if(e.file.includes(".css"))p.push(e.file)}for(let t of p){let e=await n.transformRequest(t+"?direct"),d=t.includes("module.css"),o="";if(d)o=j(c[t],e.default);b.push({isDev:!0,id:t,content:d?o:e.code})}return b.map((t,e)=>{return x("style",{key:e,type:"text/css","data-vite-dev-id":t.id,dangerouslySetInnerHTML:{__html:t.content}})})}async function L(i=[]){return i.map((n,s)=>{return x("style",{key:s,id:n?.id,type:"text/css",dangerouslySetInnerHTML:{__html:n.content}})})}import{existsSync as f}from"fs";import{basename as v}from"path";import{networkInterfaces as k}from"os";var y={name:"gemi",version:"0.59.0",private:!1,license:"MIT",author:"Enes Tufekci <enes@gemijs.dev>",repository:{type:"git",url:"git+https://github.com/nstfkc/gemi.git",directory:"packages/gemi"},bin:{gemi:"./dist/bin/gemi.js","gemi-orm-generator":"./dist/bin/orm-generator.js"},files:["dist/**/*","ide/typescript-plugin/package.json"],module:!0,exports:{"./http":"./http/index.ts","./client":"./client/index.ts","./testing":"./testing/index.ts","./app":"./app/index.ts","./facades":"./facades/index.ts","./email":"./email/index.ts","./vite":"./dist/vite/index.mjs","./kernel":"./kernel/index.ts","./services":"./services/index.ts","./broadcasting":"./broadcasting/index.ts","./i18n":"./i18n/index.ts","./dictionary":"./i18n/dictionaryRuntime.ts","./server":"./server/index.ts","./config":"./config/index.ts","./container":"./container/index.ts","./foundation":"./foundation/index.ts","./database":"./database/index.ts","./orm":"./orm/index.ts","./support":"./support/index.ts","./console/run":"./console/run.ts","./ide/typescript-plugin":"./ide/typescript-plugin/index.ts","./bun/preload":"./bun/preload.ts","./bun/plugin":"./bun/plugin.ts"},scripts:{lint:"oxlint",typecheck:"tsc --noEmit -p tsconfig.json && tsc --noEmit -p ide/typescript-plugin/tsconfig.json",build:"NODE_ENV=production bun run build:core && bun run build:bin && bun run build:types && bun run build:client && bun run build:plugin && bun run build:ts-plugin && bun run build:client-types && bun run build:augmentation","build:core":"bun ./scripts/build.ts","build:bin":"bun build --outdir=./dist/bin --target=bun --external=vite --external=react-dom --external=react/jsx-runtime --external=bun --external=sharp --external=@azure/storage-blob --sourcemap ./bin/gemi.ts ./bin/orm-generator.ts && bun ./scripts/prepare-bin.ts","build:client":"rm -rf dist/client dist/testing dist/chunks && vite build -c vite.client.config.mts","build:plugin":"vite build -c vite.plugin.config.mts","build:ts-plugin":"bun ./scripts/build-ts-plugin.ts","build:types":"tsc","build:client-types":"tsc -p tsconfig.browser.json",test:"bun --bun vitest","test:types":"vitest run --typecheck.only","test:packaging":"bun --bun vitest run --config vitest.packaging.config.ts","build:publish":"bun scripts/build-publish.ts",prepublishOnly:"echo 'Do not publish from this directory \u2014 its exports point at TS source. Run: bun run build:publish, then publish from .publish/' && exit 1","build:augmentation":"bun ./scripts/wire-augmentation.ts"},dependencies:{"@aws-sdk/client-s3":"^3.629.0","@aws-sdk/s3-request-presigner":"^3.629.0","ast-types":"^0.14.2",commander:"^12.1.0",history:"^5.3.0","jsx-email":"2.0.0-rc2.1","magic-string":"^0.30.17",open:"^10.1.0","react-error-boundary":"^6.0.0",recast:"^0.23.9",resend:"^6.12.3",satori:"^0.12.2","temporal-polyfill":"^0.2.5","twitter-api-v2":"^1.20.2","urlpattern-polyfill":"^10.0.0",uuid:"^9.0.1"},devDependencies:{"@babel/parser":"^7.25.4","@prisma/generator-helper":"^6.5.0","@repo/typescript-config":"*","@testing-library/react":"^16.3.2","@types/bun":"^1.3.14","@types/eslint":"^8.56.5","@types/node":"^20.11.24","@types/react":"^19.0.2","@types/react-dom":"^19.0.2",eslint:"^8.57.0",jsdom:"^30.0.1",oxlint:"^1.39.0",react:"19.2.3","react-dom":"19.2.3",typescript:"^5.7.3",vitest:"^4.0.0"},peerDependencies:{"@azure/storage-blob":"^12.28.0",react:">=19","react-dom":">=19",sharp:"^0.34.2",vite:"^8.0.0"},peerDependenciesMeta:{"@azure/storage-blob":{optional:!0}}};var z=[" \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2557","\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551","\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551","\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551","\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551"," \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D"],O=Boolean(process.stdout.isTTY)&&!process.env.NO_COLOR,g=(i,n)=>O?`\x1B[${i}m${n}\x1B[0m`:n,T=(i)=>g("1",i),l=(i)=>g("2",i),a=(i)=>g("36",i),q=(i)=>g("32",i),E=(i)=>g("35",i);function R(){return y.version??"?"}function _(i){for(let n of Object.values(k()))for(let s of n??[])if((s.family==="IPv4"||s.family===4)&&!s.internal)return`http://${s.address}:${i}`;return null}function G(i){return h(i).filter((n)=>f(n)).map((n)=>v(n))}function A(i){let{port:n,rootDir:s}=i,r=`http://localhost:${n}`,u=_(n),b=G(s),p=(t,e)=>`  ${q("\u279C")}  ${T(t.padEnd(9))}${e}`,c=["",...z.map((t)=>E(t)),"",`  ${l("gemi")} ${a(`v${R()}`)}`,"",p("Local:",a(r)),p("Network:",u?a(u):l("unavailable")),p("Env:",b.length?b.join(", "):l("none")),""];console.log(c.join(`
-`))}
-export{J as Z,L as _,A as $};
-
-//# debugId=729A5B226DC8C37F64756E2164756E21