create-geonosis 2.13.0 → 3.0.0

package/dist/index.d.ts

@@ -1,170 +1,7 @@
-declare const RUNTIMES: readonly ["bun", "pnpm"];
-declare const BACKENDS: readonly ["medusa", "none", "sagaflow-cf"];
-declare const UIS: readonly ["atoms-only", "none", "tiered-shadcn"];
-type Runtime = (typeof RUNTIMES)[number];
-type Backend = (typeof BACKENDS)[number];
-type Ui = (typeof UIS)[number];
-type Answers = {
-    backend: Backend;
-    brand?: string;
-    dir: string;
-    /** The domains this repo composes at its composition root. Empty until the flag names one. */
-    domains: string[];
-    /** The kit read from a workspace instead of the registry — a proof aid, never the default. */
-    kit?: string;
-    marketplace?: string;
-    /** The Medusa range a `--backend medusa` tree declares. `MEDUSA_RANGE` unless one is named. */
-    medusa?: string;
-    name: string;
-    runtime: Runtime;
-    scope: string;
-    themekit?: string;
-    ui: Ui;
-};
-declare const parseAnswers: (argv: readonly string[], cwd: string) => Answers;
-declare const wantsInstall: (argv: readonly string[]) => boolean;
-
-/**
- * What an existing repo never receives: whatever the scaffold has learned since it was run.
- *
- * The comparison is over SHAPE and not over content, because a repo that has been worked in has
- * legitimately rewritten every file the scaffold gave it. What it cannot have legitimately done is
- * lose a file the scaffold now writes, or miss a declaration a new gate reads — so a missing path is
- * drift and a changed value never is.
- */
-type DriftKind = 'key' | 'missing' | 'unreadable';
-type Drift = {
-    /** The key path inside the file, or `''` when the fact is about the whole file. */
-    at: string;
-    file: string;
-    kind: DriftKind;
-};
-/**
- * The drift between a tree and what the scaffold would write into it today. Reads only.
- *
- * Nothing in this module opens a file for writing, and nothing calls `writeScaffold`. That is the
- * whole contract of `--check`: it is run against a repo somebody is working in.
- */
-declare const checkScaffold: (answers: Answers) => Drift[];
-declare const describeDrift: (drift: readonly Drift[]) => string[];
-
-/** Where the composition root lives, relative to the workspace that composes: the app. */
-declare const PLATFORM_FILE = "src/platform.ts";
-/**
- * A domain the kit ships, and the two lines composing it takes.
- *
- * A domain is added here and nowhere else: the flag's vocabulary, the app's dependencies and the
- * generated file all read this table, so a domain that ships without a way to compose it cannot be
- * offered by name. `version` is the floor package's OWN line — the method's number says nothing
- * about it (D-053) — and `tooling/floor-scaffold-versions.test.ts` holds each against the workspace.
- */
-type DomainScaffold = {
-    /** Where the package sits in the kit's tree, for `--kit`'s workspace links. */
-    at: string;
-    /** What the scope field is called, and the type it is annotated with. */
-    field: string;
-    /** Everything the generated file needs above the composition itself. */
-    declarations: readonly string[];
-    fieldType: string;
-    imports: readonly string[];
-    name: string;
-    /** How the store is built, once the tenant's transaction is already open. */
-    built: readonly string[];
-    version: string;
-};
-declare const DOMAINS: readonly DomainScaffold[];
-declare const DOMAIN_NAMES: readonly string[];
-/** The two foundations a composition root is built from, whichever domains it composes. */
-declare const FOUNDATIONS: readonly {
-    at: string;
-    name: string;
-    version: string;
-}[];
-declare const domainsNamed: (named: readonly string[]) => DomainScaffold[];
-/** What the composing workspace declares once a domain is named. */
-declare const floorDependencies: (named: readonly string[]) => Record<string, string>;
-/** Every kit directory a `--kit` link has to reach for the domains this repo named. */
-declare const floorDirectories: (named: readonly string[]) => string[];
-/**
- * The composition root, in the two lifetimes it has.
- *
- * DEFINITIONS are what this deployment IS — wired once per isolate, before anybody has asked
- * anything. SCOPE is who is asking, bound per request. Keeping them apart is what lets the session
- * come first: the stores are built INSIDE the tenant's transaction, so a caller cannot hold one
- * that was made without a session to run in (D-014 — structural, never an assertion).
- */
-declare const platformSource: (named: readonly string[]) => string;
-
-type Workspace = {
-    dir: string;
-    /** The files under this workspace, keyed by path relative to the workspace. */
-    sources: Record<string, string>;
-    name: string;
-    /** Packages outside the workspace this one declares, spec and all. */
-    packages?: Record<string, string>;
-    tag: string;
-    mayDependOn: string[];
-};
-/**
- * The workspaces the answers imply, and the edge each one is allowed. Two at minimum — a pure-logic
- * package and the app that composes it — because a wall needs something on the other side of it: a
- * repo with one tag has no edge to violate, and a `layer-walls` that cannot fire is the inert rule
- * this kit exists to catch.
- */
-declare const workspacesOf: (answers: Answers) => Workspace[];
-
-declare const CORPUS_DIR = "lint-corpus";
-/**
- * A reach corpus a shipped one cannot be.
- *
- * `geonosis-doctor` asks whether every enabled rule can fire at all, and it asks the corpus the
- * PLUGIN ships. That cannot answer for a rule whose reach is the repo's own vocabulary: its layer
- * names, its brand, its plugin package root, the `within` its sagas live in. The plugin's corpus
- * says "acme" and `layers/core`, so it is no evidence either way about a repo that says anything
- * else — and those rules would read as firing nowhere.
- *
- * So the repo ships its own, in ITS vocabulary. The corpus is copied to a temp root and linted with
- * `--no-ignore`, so the fixture paths mirror the repo's real ones and the layer patterns match.
- */
-declare const corpusFor: (answers: Answers, workspaces: Workspace[]) => Record<string, string>;
-
-declare const filesFor: (answers: Answers) => Record<string, string>;
-declare const presetsChosenBy: (answers: Answers) => string[];
-
-/** The kit packages a scaffolded repo RESOLVES, and therefore the ones `--kit` has to link. */
-declare const KIT_PACKAGES: string[];
-/**
- * Every file, and never over the top of anything. A scaffold that overwrote a tree is a scaffold
- * nobody dares run in the wrong shell, and the tree it lands in is usually somebody's work.
- */
-declare const writeScaffold: (answers: Answers) => string[];
-type Step = {
-    code: number;
-    output: string;
-    what: string;
-};
-/**
- * The kit read from a workspace instead of the registry — a proof aid, and only that.
- *
- * It is done by hand, after the install, because neither package manager can do it: pnpm resolves
- * `link:` happily, and bun refuses BOTH `link:` and `file:` here, because it follows into the target
- * and tries to resolve the `workspace:*` specifiers the kit's own packages use. Symlinking the
- * directories and writing the bin shims is the one form of the answer that is true on both.
- *
- * The manifests are then told what is on disk, because `geonosis-doctor` FAILS a config whose plugin
- * no manifest declares — and it should. A link is a declaration it accepts and can verify.
- */
-declare const linkKit: (answers: Answers, kit: string) => string[];
-/**
- * What has to happen after the files exist, in the order it has to happen in.
- *
- * The two `sync` calls are why the scaffold does not compute a boundaries map or a layer list of
- * its own: the edges table is the ONE place the graph is written, and the ledger is the one thing
- * that reads it. A second generator here would be a second answer to the same question.
- */
-declare const finish: ({ answers, install }: {
-    answers: Answers;
-    install: boolean;
-}) => Step[];
-
-export { type Answers, BACKENDS, type Backend, CORPUS_DIR, DOMAINS, DOMAIN_NAMES, type DomainScaffold, type Drift, type DriftKind, FOUNDATIONS, KIT_PACKAGES, PLATFORM_FILE, RUNTIMES, type Runtime, type Step, UIS, type Ui, type Workspace, checkScaffold, corpusFor, describeDrift, domainsNamed, filesFor, finish, floorDependencies, floorDirectories, linkKit, parseAnswers, platformSource, presetsChosenBy, wantsInstall, workspacesOf, writeScaffold };
+export { type Answers, type Backend, BACKENDS, parseAnswers, type Runtime, RUNTIMES, type Ui, UIS, wantsInstall } from './answers.js';
+export { checkScaffold, describeDrift, type Drift, type DriftKind } from './check.js';
+export { DOMAIN_NAMES, DOMAINS, type DomainScaffold, domainsNamed, floorDependencies, floorDirectories, FOUNDATIONS, PLATFORM_FILE, platformSource } from './composition.js';
+export { CORPUS_DIR, corpusFor } from './corpus.js';
+export { filesFor, presetsChosenBy } from './files.js';
+export { type Workspace, workspacesOf } from './layout.js';
+export { finish, KIT_PACKAGES, linkKit, type Step, writeScaffold } from './scaffold.js';

package/dist/index.js

@@ -1,29 +1,26 @@
+// src/index.ts
 import {
   BACKENDS,
-  CORPUS_DIR,
-  DOMAINS,
-  DOMAIN_NAMES,
-  FOUNDATIONS,
-  KIT_PACKAGES,
-  PLATFORM_FILE,
+  parseAnswers,
   RUNTIMES,
   UIS,
-  checkScaffold,
-  corpusFor,
-  describeDrift,
+  wantsInstall
+} from "./answers.js";
+import { checkScaffold, describeDrift } from "./check.js";
+import {
+  DOMAIN_NAMES,
+  DOMAINS,
   domainsNamed,
-  filesFor,
-  finish,
   floorDependencies,
   floorDirectories,
-  linkKit,
-  parseAnswers,
-  platformSource,
-  presetsChosenBy,
-  wantsInstall,
-  workspacesOf,
-  writeScaffold
-} from "./chunk-LUUI74BB.js";
+  FOUNDATIONS,
+  PLATFORM_FILE,
+  platformSource
+} from "./composition.js";
+import { CORPUS_DIR, corpusFor } from "./corpus.js";
+import { filesFor, presetsChosenBy } from "./files.js";
+import { workspacesOf } from "./layout.js";
+import { finish, KIT_PACKAGES, linkKit, writeScaffold } from "./scaffold.js";
 export {
   BACKENDS,
   CORPUS_DIR,

package/dist/layout.d.ts

@@ -0,0 +1,18 @@
+import { type Answers } from './answers.js';
+export type Workspace = {
+    dir: string;
+    /** The files under this workspace, keyed by path relative to the workspace. */
+    sources: Record<string, string>;
+    name: string;
+    /** Packages outside the workspace this one declares, spec and all. */
+    packages?: Record<string, string>;
+    tag: string;
+    mayDependOn: string[];
+};
+/**
+ * The workspaces the answers imply, and the edge each one is allowed. Two at minimum — a pure-logic
+ * package and the app that composes it — because a wall needs something on the other side of it: a
+ * repo with one tag has no edge to violate, and a `layer-walls` that cannot fire is the inert rule
+ * this kit exists to catch.
+ */
+export declare const workspacesOf: (answers: Answers) => Workspace[];

package/dist/layout.js

@@ -0,0 +1,164 @@
+// src/layout.ts
+import { MEDUSA_PACKAGES, MEDUSA_RANGE } from "./answers.js";
+import { floorDependencies, PLATFORM_FILE, platformSource } from "./composition.js";
+var CORE = `export type Money = { amount: number; currency: string }
+
+export const totalOf = (lines: readonly Money[], currency: string): Money => ({
+  amount: lines.filter((one) => one.currency === currency).reduce((sum, one) => sum + one.amount, 0),
+  currency,
+})
+`;
+var CORE_TEST = (scope) => `import { describe, expect, it } from 'vitest'
+
+import { totalOf } from './money'
+
+describe('totalOf', () => {
+  it('adds the lines that share the currency', () => {
+    expect(totalOf([{ amount: 2, currency: 'EUR' }, { amount: 3, currency: 'EUR' }], 'EUR')).toEqual(
+      { amount: 5, currency: 'EUR' },
+    )
+  })
+
+  it('ignores the ones that do not — ${scope}/core never guesses a rate', () => {
+    expect(totalOf([{ amount: 2, currency: 'EUR' }, { amount: 9, currency: 'USD' }], 'EUR').amount)
+      .toBe(2)
+  })
+})
+`;
+var BUTTON = `import type { ComponentProps } from 'react'
+
+export function Button(props: ComponentProps<'button'>) {
+  return <button type="button" {...props} />
+}
+`;
+var FIELD = (scope) => `import { Button } from '${scope}/ui/atoms/button'
+
+export function Field({ label, onSubmit }: { label: string; onSubmit: () => void }) {
+  return (
+    <label>
+      {label}
+      <Button onClick={onSubmit}>Go</Button>
+    </label>
+  )
+}
+`;
+var UI_TEST = `import { describe, expect, it } from 'vitest'
+
+import { Button } from './atoms/button'
+
+describe('Button', () => {
+  it('is a component, so a tier above can compose it', () => {
+    expect(typeof Button).toBe('function')
+  })
+})
+`;
+var MEDUSA_SUBSCRIBER = `export const config = {
+  context: { subscriberId: 'order-placed' },
+  event: 'order.placed',
+}
+
+export default async function orderPlaced({ data }: { data: { id: string } }): Promise<string> {
+  return data.id
+}
+`;
+var SAGAFLOW_STEP = `export const step = <Input, Output>(
+  name: string,
+  body: (input: Input) => Promise<Output>,
+  undo: (output: Output) => Promise<void>,
+) => ({ body, name, undo })
+`;
+var SAGAFLOW_FLOW = `import { step } from './step'
+
+export const reserve = step(
+  'reserve',
+  async (input: { id: string }) => ({ held: input.id }),
+  async () => undefined,
+)
+`;
+var BACKEND_TEST = `import { describe, expect, it } from 'vitest'
+
+import { handler } from './handler'
+
+describe('the backend seam', () => {
+  it('answers with what it was asked about', async () => {
+    expect(await handler({ id: 'ord_1' })).toBe('ord_1')
+  })
+})
+`;
+var HANDLER = `export const handler = async ({ id }: { id: string }): Promise<string> => id
+`;
+var APP = (scope, ui) => ui ? `import { totalOf } from '${scope}/core/money'
+import { Button } from '${scope}/ui/atoms/button'
+
+export const boot = () => ({ button: Button, total: totalOf([], 'EUR') })
+` : `import { totalOf } from '${scope}/core/money'
+
+export const boot = () => ({ total: totalOf([], 'EUR') })
+`;
+var APP_TEST = `import { describe, expect, it } from 'vitest'
+
+import { boot } from './boot'
+
+describe('boot', () => {
+  it('starts with an empty total rather than a guess', () => {
+    expect(boot().total.amount).toBe(0)
+  })
+})
+`;
+var workspacesOf = (answers) => {
+  const { scope, ui } = answers;
+  const list = [
+    {
+      dir: "packages/core",
+      mayDependOn: [],
+      name: `${scope}/core`,
+      sources: { "src/money.ts": CORE, "src/money.test.ts": CORE_TEST(scope) },
+      tag: "core"
+    }
+  ];
+  if (ui !== "none") {
+    list.push({
+      dir: "packages/ui",
+      mayDependOn: ["core"],
+      name: `${scope}/ui`,
+      sources: {
+        "src/atoms/button.tsx": BUTTON,
+        "src/button.test.ts": UI_TEST,
+        ...ui === "tiered-shadcn" ? { "src/molecules/field.tsx": FIELD(scope) } : {}
+      },
+      tag: "ui"
+    });
+  }
+  if (answers.backend !== "none") {
+    list.push({
+      dir: "packages/backend",
+      mayDependOn: ["core"],
+      name: `${scope}/backend`,
+      ...answers.backend === "medusa" ? {
+        packages: Object.fromEntries(MEDUSA_PACKAGES.map((one) => [one, answers.medusa ?? MEDUSA_RANGE]))
+      } : {},
+      sources: {
+        "src/handler.ts": HANDLER,
+        "src/handler.test.ts": BACKEND_TEST,
+        ...answers.backend === "medusa" ? { "src/subscribers/order-placed.ts": MEDUSA_SUBSCRIBER } : { "src/workflows/step.ts": SAGAFLOW_STEP, "src/workflows/reserve.ts": SAGAFLOW_FLOW }
+      },
+      tag: "backend"
+    });
+  }
+  list.push({
+    dir: "apps/web",
+    mayDependOn: list.map((one) => one.tag),
+    name: `${scope}/web`,
+    packages: floorDependencies(answers.domains),
+    sources: {
+      "src/boot.ts": APP(scope, ui !== "none"),
+      "src/boot.test.ts": APP_TEST,
+      ...answers.domains.length === 0 ? {} : { [PLATFORM_FILE]: platformSource(answers.domains) }
+    },
+    tag: "app"
+  });
+  return list;
+};
+export {
+  workspacesOf
+};

package/dist/scaffold.d.ts

@@ -0,0 +1,36 @@
+import type { Answers } from './answers.js';
+/** The kit packages a scaffolded repo RESOLVES, and therefore the ones `--kit` has to link. */
+export declare const KIT_PACKAGES: string[];
+/**
+ * Every file, and never over the top of anything. A scaffold that overwrote a tree is a scaffold
+ * nobody dares run in the wrong shell, and the tree it lands in is usually somebody's work.
+ */
+export declare const writeScaffold: (answers: Answers) => string[];
+export type Step = {
+    code: number;
+    output: string;
+    what: string;
+};
+/**
+ * The kit read from a workspace instead of the registry — a proof aid, and only that.
+ *
+ * It is done by hand, after the install, because neither package manager can do it: pnpm resolves
+ * `link:` happily, and bun refuses BOTH `link:` and `file:` here, because it follows into the target
+ * and tries to resolve the `workspace:*` specifiers the kit's own packages use. Symlinking the
+ * directories and writing the bin shims is the one form of the answer that is true on both.
+ *
+ * The manifests are then told what is on disk, because `geonosis-doctor` FAILS a config whose plugin
+ * no manifest declares — and it should. A link is a declaration it accepts and can verify.
+ */
+export declare const linkKit: (answers: Answers, kit: string) => string[];
+/**
+ * What has to happen after the files exist, in the order it has to happen in.
+ *
+ * The two `sync` calls are why the scaffold does not compute a boundaries map or a layer list of
+ * its own: the edges table is the ONE place the graph is written, and the ledger is the one thing
+ * that reads it. A second generator here would be a second answer to the same question.
+ */
+export declare const finish: ({ answers, install }: {
+    answers: Answers;
+    install: boolean;
+}) => Step[];

package/dist/scaffold.js

@@ -0,0 +1,173 @@
+// src/scaffold.ts
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  symlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { floorDirectories } from "./composition.js";
+import { filesFor, GRAPH_SYNCS, kitDependencies } from "./files.js";
+import { workspacesOf } from "./layout.js";
+var KIT_PACKAGES = [
+  "cli",
+  "doctor",
+  "ledger",
+  "lint-parity",
+  "oxlint-plugin-biological-architecture",
+  "ratchet",
+  "themekit",
+  "verify"
+];
+var write = (dir, file, body) => {
+  const path = join(dir, file);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, body);
+};
+var readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+var writeScaffold = (answers) => {
+  if (existsSync(answers.dir) && readdirSync(answers.dir).length > 0) {
+    throw new Error(`${answers.dir} is not empty — nothing was written`);
+  }
+  const files = filesFor(answers);
+  mkdirSync(answers.dir, { recursive: true });
+  for (const [file, body] of Object.entries(files))
+    write(answers.dir, file, body);
+  return Object.keys(files).toSorted();
+};
+var run = (what, dir, command, args) => {
+  const done = spawnSync(command, args, { cwd: dir, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  return {
+    code: done.error === undefined ? done.status ?? 2 : 2,
+    output: `${done.stdout ?? ""}${done.stderr ?? ""}${done.error === undefined ? "" : done.error.message}`,
+    what
+  };
+};
+var binsOf = (dir) => {
+  const manifest = readJson(join(dir, "package.json"));
+  if (typeof manifest.bin === "string")
+    return [[manifest.name ?? "", manifest.bin]];
+  return Object.entries(manifest.bin ?? {});
+};
+var repoint = (path, at, owed) => {
+  if (!existsSync(path))
+    return [];
+  const manifest = readJson(path);
+  const moved = [];
+  for (const block of ["dependencies", "devDependencies"]) {
+    const declared = manifest[block];
+    if (declared === undefined)
+      continue;
+    for (const name of Object.keys(declared)) {
+      const from = at.get(name);
+      if (from === undefined)
+        continue;
+      declared[name] = `link:${from}`;
+      moved.push(name);
+    }
+  }
+  for (const name of owed) {
+    const from = at.get(name);
+    if (from === undefined || moved.includes(name))
+      continue;
+    manifest.dependencies = { ...manifest.dependencies, [name]: `link:${from}` };
+    moved.push(name);
+  }
+  if (moved.length > 0)
+    writeFileSync(path, `${JSON.stringify(manifest, undefined, 2)}
+`);
+  return moved;
+};
+var linkKit = (answers, kit) => {
+  const modules = join(answers.dir, "node_modules");
+  const scope = join(modules, "@geonosis");
+  const bin = join(modules, ".bin");
+  mkdirSync(scope, { recursive: true });
+  mkdirSync(bin, { recursive: true });
+  const linked = [];
+  const at = new Map;
+  const manifestPath = join(answers.dir, "package.json");
+  const manifest = readJson(manifestPath);
+  for (const relative of [
+    ...KIT_PACKAGES.map((name) => `packages/${name}`),
+    ...floorDirectories(answers.domains)
+  ]) {
+    const from = join(kit, relative);
+    if (!existsSync(from))
+      continue;
+    const declared = readJson(join(from, "package.json"));
+    if (declared.name === undefined)
+      continue;
+    const to = join(scope, declared.name.replace("@geonosis/", ""));
+    if (!existsSync(to))
+      symlinkSync(from, to);
+    for (const [called, entry] of binsOf(from)) {
+      const shim = join(bin, called);
+      writeFileSync(shim, `#!/bin/sh
+exec node "${join(from, entry)}" "$@"
+`);
+      chmodSync(shim, 493);
+    }
+    at.set(declared.name, from);
+    linked.push(relative);
+  }
+  const owned = new Set(workspacesOf(answers).flatMap((workspace) => repoint(join(answers.dir, workspace.dir, "package.json"), at, Object.keys(workspace.packages ?? {}))));
+  const rootDeclares = new Set(Object.keys(kitDependencies(answers)));
+  for (const [name, from] of at) {
+    if (!owned.has(name) && rootDeclares.has(name)) {
+      manifest.devDependencies = { ...manifest.devDependencies, [name]: `link:${from}` };
+    }
+  }
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, undefined, 2)}
+`);
+  return linked;
+};
+var installer = (answers) => answers.runtime === "bun" ? ["bun", ["install"]] : ["pnpm", ["install"]];
+var finish = ({ answers, install }) => {
+  const steps = [];
+  if (install) {
+    const [command, args] = installer(answers);
+    const offline = answers.runtime === "pnpm" ? [...args, "--offline"] : args;
+    const first = run(`${command} install (offline)`, answers.dir, command, offline);
+    steps.push(first);
+    if (first.code !== 0) {
+      steps.push(run(`${command} install (network)`, answers.dir, command, args));
+    }
+  }
+  if (answers.kit !== undefined) {
+    const linked = linkKit(answers, answers.kit);
+    steps.push({
+      code: 0,
+      output: `${linked.join(", ")}
+`,
+      what: `link the kit from ${answers.kit}`
+    });
+  }
+  const ledger = join(answers.dir, "node_modules/.bin/geonosis-ledger");
+  if (existsSync(ledger)) {
+    for (const { target, write: into } of GRAPH_SYNCS) {
+      steps.push(run(`sync the edges table into ${into}`, answers.dir, ledger, [
+        "sync",
+        "--target",
+        target,
+        "--write",
+        into
+      ]));
+    }
+  }
+  const oxfmt = join(answers.dir, "node_modules/.bin/oxfmt");
+  if (existsSync(oxfmt)) {
+    steps.push(run("format", answers.dir, oxfmt, ["--config", ".oxfmtrc.json", "."]));
+  }
+  return steps;
+};
+export {
+  KIT_PACKAGES,
+  finish,
+  linkKit,
+  writeScaffold
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-geonosis",
-  "version": "2.13.0",
+  "version": "3.0.0",
   "types": "./dist/index.d.ts",
   "description": "Scaffold a microcompany repo that passes its own geonosis gates on day one.",
   "keywords": [
@@ -35,16 +35,17 @@
     "dist"
   ],
   "dependencies": {
-    "@geonosis/cli": "2.13.0"
+    "@geonosis/cli": "3.0.0"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22",
+    "bun": "^1.4.2"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsx ../../tooling/build-step.ts tsup",
+    "build": "bun ../../tooling/build-step.ts bun ../../tooling/bundle.ts",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint --config ../../.oxlintrc.json .",
     "test:unit": "vitest run --project unit --root ../.. --passWithNoTests \"$PWD\"",