create-geonosis 2.13.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # create-geonosis
 
+## 3.0.0
+
+### Major Changes
+
+- 670f7c1: Every bin runs on bun: its shebang is `#!/usr/bin/env bun`, so a repo that runs the tools needs bun on `PATH`. On pnpm 12, `devEngines.runtime` names it and the install puts it in `node_modules/.bin`:
+  
+  ```json
+  "devEngines": { "runtime": { "name": "bun", "version": "^1.4.2", "onFail": "download" } }
+  ```
+  
+  The runtime floors (foundations, domains, kits) are unchanged: they declare no runtime of their own and run on Node, Workers or a browser bundle.
+
+### Minor Changes
+
+- 0f272e2: A tree says which bun the kit's bins start on. Every package with a bin declares `engines.bun`, at the range the kit itself runs. `create-geonosis` writes a pnpm repo's `devEngines.runtime` and `packageManager` as the kit's own manifest has them, so pnpm 12 installs that bun. `geonosis-doctor`'s drift check WARNs, on the `tool runtime` line, where an installed kit package asks for bun and the root neither runs on it nor declares it, and prints the block to add.
+- 29a4820: TypeScript 7. A scaffold pins the tools at the ranges the kit itself runs, read from the kit's own manifest when a cut is made, so the two cannot drift: `typescript` ^7, `oxlint` ^1.85, `oxfmt` ^0.70.
+
+### Patch Changes
+
+- 1e38e4e: `geonosis-themekit`, `geonosis-rails` and `geonosis-evals` read their arguments with `node:util`'s `parseArgs`. A flag one does not know is refused by name, exit 2, where the hand-written readers ignored it and ran without it; a flag given twice keeps its last value in all three (evals kept the first). `geonosis-evals compare --tolerance x=0.1 a.json b.json` reads `a.json` and `b.json` as the scores: the old reader took the tolerance's value for the first score file. `geonosis-ratchet` and `geonosis-verify`, which already refused what they did not know, read their flags the same way; verify still refuses a flag that belongs to another of its commands. `geonosis-doctor` reads its flags with `parseArgs` too, its optional `--baseline-against` ref through the parser's tokens. `@geonosis/ledger`'s exported `parseArgs(argv, valued, switches)` is `node:util`'s underneath and takes the switches it accepts, refusing an undeclared one and a valued flag followed by another flag (`--note --plan 3` used to store `--plan` as the note); `rejectUnknownSwitches` is gone. `geonosis-walk`, `geonosis-review` and `geonosis-lint-parity` parse the same way; parity keeps its own words for a bare `--corpus` or `--expect-changed`. `geonosis-observability`, `geonosis-verify-arch`, `geonosis-testbed` and `geonosis-visual-diff` follow; the last two used to accept a flag they did not know (testbed ignored it, visual-diff read it as a switch) and now refuse it. `@geonosis/release`'s exported `parseArgs` keeps its `Parsed` shape over `node:util`'s. `@geonosis/cli`'s `parseArgv` and `create-geonosis`'s `parseArgs` are built on it too, keeping their own refusals; `parseArgv` now refuses a valued flag followed by another flag instead of taking that flag as its value.
+- Updated dependencies [1e38e4e]
+  - @geonosis/cli@3.0.0
+
 ## 2.13.0
 
 ### Patch Changes

package/bin/create-geonosis.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 // Generated by pnpm generate:shims. In the kit's own tree src/ sits beside dist/, and a dist older
 // than src once answered for a fix it did not carry (#62); a published package ships no src/.
 import { existsSync } from 'node:fs'

package/dist/adopt.js

@@ -0,0 +1,144 @@
+// src/adopt.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { countersFor, rulesFor, runtimeOf, tiersFor } from "@geonosis/cli";
+import { BACKENDS, scopeOf, UIS } from "./answers.js";
+import { checkScaffold } from "./check.js";
+var ADOPT_USAGE = "create-geonosis --plan <dir> [--presets <a,b>] [--runtime pnpm|bun] [--backend medusa|sagaflow-cf|none] [--ui tiered-shadcn|atoms-only|none] — what adopting this repo would take, computed off the tree. Writes nothing.";
+var LOCKFILES = ["bun.lock", "bun.lockb", "pnpm-lock.yaml"];
+var MEDUSA = "@medusajs/";
+var WORKERS = ["wrangler", "@cloudflare/workers-types", "sagaflow-js"];
+var readJson = (at) => {
+  if (!existsSync(at))
+    return;
+  try {
+    return JSON.parse(readFileSync(at, "utf8"));
+  } catch {
+    return;
+  }
+};
+var manifestsIn = (dir) => {
+  const found = [readJson(join(dir, "package.json"))];
+  for (const group of ["apps", "packages"]) {
+    const at = join(dir, group);
+    if (!existsSync(at))
+      continue;
+    for (const entry of readdirSync(at, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        found.push(readJson(join(at, entry.name, "package.json")));
+    }
+  }
+  return found.filter((one) => one !== undefined);
+};
+var dependencyNames = (manifests) => manifests.flatMap((one) => [
+  ...Object.keys(one.dependencies ?? {}),
+  ...Object.keys(one.devDependencies ?? {})
+]);
+var backendOf = (manifests) => {
+  const names = dependencyNames(manifests);
+  if (names.some((one) => one.startsWith(MEDUSA)))
+    return "medusa";
+  if (names.some((one) => WORKERS.includes(one)))
+    return "sagaflow-cf";
+  return "none";
+};
+var chosen = (flag, given, allowed) => {
+  if (given === undefined)
+    return;
+  if (!allowed.includes(given)) {
+    throw new Error(`${flag} "${given}" is not one of ${allowed.join(", ")}`);
+  }
+  return given;
+};
+var uiOf = (dir, given) => {
+  if (given !== undefined)
+    return given;
+  if (!existsSync(join(dir, "packages/ui")))
+    return "none";
+  throw new Error(`${dir} has a packages/ui and no --ui was given — the tier decides which rules the plan proposes, and a directory listing cannot say which tier it is. Name --ui ${UIS.join("|")}.`);
+};
+var doorFor = (block) => `@geonosis/${block}`;
+var KIT_OWNED_BLOCKS = ["ledger", "review", "testbed", "verify", "walk"];
+var planAdoption = ({ backend, dir, presets, runtime, ui }) => {
+  const at = resolve(dir);
+  if (!existsSync(at))
+    throw new Error(`${at} is not there — --plan reads a repo, it never makes one`);
+  const manifests = manifestsIn(at);
+  const chosenRuntime = chosen("--runtime", runtime, ["bun", "pnpm"]) ?? runtimeOf(at);
+  if (chosenRuntime === undefined) {
+    throw new Error(`${at} has none of ${LOCKFILES.join(", ")}, so nothing there says which package manager it runs — name --runtime pnpm|bun.`);
+  }
+  const answers = {
+    backend: chosen("--backend", backend, BACKENDS) ?? backendOf(manifests),
+    dir: at,
+    domains: [],
+    name: basename(at),
+    runtime: chosenRuntime,
+    scope: scopeOf(basename(at)),
+    ui: uiOf(at, chosen("--ui", ui, UIS))
+  };
+  const drift = checkScaffold(answers);
+  const enabled = new Set(Object.keys(readJson(join(at, ".oxlintrc.json"))?.rules ?? {}));
+  const config = readJson(join(at, "geonosis.json")) ?? {};
+  const declaredTiers = config["verify"] ?? {};
+  const declaredCounters = new Set((readJson(join(at, "geonosis.ratchet.json"))?.counters ?? []).map((one) => one.key ?? one.counter ?? ""));
+  const declaredPackages = new Set(dependencyNames(manifests));
+  const { unanswered } = rulesFor(presets);
+  const tiers = tiersFor({
+    rules: {},
+    runtime: chosenRuntime,
+    scripts: Object.keys(readJson(join(at, "package.json"))?.scripts ?? {})
+  });
+  return {
+    backend: answers.backend,
+    counters: countersFor(chosenRuntime, "LAW.md").map((one) => {
+      const key = typeof one["key"] === "string" ? one["key"] : String(one["counter"]);
+      return { declared: declaredCounters.has(key), key };
+    }),
+    dir: at,
+    doors: KIT_OWNED_BLOCKS.map((block) => ({
+      block,
+      declared: declaredPackages.has(doorFor(block)),
+      package: doorFor(block)
+    })),
+    files: drift.filter((one) => one.kind === "missing"),
+    keys: drift.filter((one) => one.kind === "key"),
+    presets: presets.map((name) => {
+      const brings = Object.keys(rulesFor([name]).rules);
+      return {
+        brings: brings.length,
+        enabled: brings.filter((id) => enabled.has(id)),
+        name
+      };
+    }),
+    runtime: chosenRuntime,
+    tiers: Object.entries(tiers).map(([name, steps]) => ({
+      declared: Object.hasOwn(declaredTiers, name),
+      name,
+      steps
+    })),
+    ui: answers.ui,
+    unanswered,
+    unreadable: drift.filter((one) => one.kind === "unreadable")
+  };
+};
+var section = (title, lines) => lines.length === 0 ? [`${title} — none`, ""] : [`${title} (${lines.length})`, ...lines, ""];
+var formatPlan = (plan) => [
+  `adoption plan for ${plan.dir}`,
+  `  runtime ${plan.runtime} · backend ${plan.backend} · ui ${plan.ui}`,
+  "",
+  ...section("FILES the scaffold writes and this repo has none of", plan.files.map((one) => `  ${one.file}`)),
+  ...section("KEYS the scaffold declares inside a file this repo has", plan.keys.map((one) => `  ${one.file} → ${one.at}`)),
+  ...section("RULES the presets bring", plan.presets.map((one) => `  ${one.name}: ${one.brings} rules, ${one.enabled.length} already enabled here`)),
+  ...section("RULES left out until somebody answers their option", plan.unanswered.map(([rule, option]) => `  ${rule} needs \`${option}\``)),
+  ...section("COUNTERS the ratchet would run", plan.counters.map((one) => `  ${one.key}${one.declared ? " — declared" : ""}`)),
+  ...section("TIERS", plan.tiers.map((one) => `  ${one.name}${one.declared ? " — declared" : ""}`)),
+  ...section("DOORS a block needs declared", plan.doors.map((one) => `  ${one.package} for "${one.block}"${one.declared ? " — declared" : ""}`)),
+  ...plan.unreadable.length === 0 ? [] : section("FILES this check could not read as JSON", plan.unreadable.map((one) => `  ${one.file}`))
+].join(`
+`);
+export {
+  ADOPT_USAGE,
+  formatPlan,
+  planAdoption
+};

package/dist/answers.d.ts

@@ -0,0 +1,42 @@
+export declare const RUNTIMES: readonly ['bun', 'pnpm'];
+export declare const BACKENDS: readonly ['medusa', 'none', 'sagaflow-cf'];
+export declare const UIS: readonly ['atoms-only', 'none', 'tiered-shadcn'];
+export type Runtime = (typeof RUNTIMES)[number];
+export type Backend = (typeof BACKENDS)[number];
+export type Ui = (typeof UIS)[number];
+/**
+ * The Medusa the `--backend medusa` scaffold declares.
+ *
+ * MEASURED 2026-09-02: the one Medusa consumer of this kit runs `^2.19.0`. The scaffold turns the
+ * Medusa rules on, and a tree that enables them while declaring no `@medusajs/*` earns nine
+ * `exercised` WARNs — rules with no possible finding, which read exactly like a clean tree (#228).
+ * A range nobody has measured against is worse than none, so this one is the default and
+ * `--medusa <range>` is how a repo on another one says so.
+ */
+export declare const MEDUSA_RANGE = "^2.19.0";
+export declare const MEDUSA_PACKAGES: readonly ['@medusajs/framework', '@medusajs/medusa'];
+export 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;
+};
+export declare const parseArgs: (argv: readonly string[]) => {
+    flags: Record<string, string>;
+    dir?: string;
+};
+/** A package scope from the repo's own name, lowercased, so `@Pinecone/core` is never written. */
+export declare const scopeOf: (name: string) => string;
+export declare const parseAnswers: (argv: readonly string[], cwd: string) => Answers;
+export declare const wantsInstall: (argv: readonly string[]) => boolean;

package/dist/answers.js

@@ -0,0 +1,111 @@
+// src/answers.ts
+import { basename, resolve } from "node:path";
+import { parseArgs as readArgv } from "node:util";
+import { domainsNamed } from "./composition.js";
+var RUNTIMES = ["bun", "pnpm"];
+var BACKENDS = ["medusa", "none", "sagaflow-cf"];
+var UIS = ["atoms-only", "none", "tiered-shadcn"];
+var MEDUSA_RANGE = "^2.19.0";
+var MEDUSA_PACKAGES = ["@medusajs/framework", "@medusajs/medusa"];
+var VALUED = new Set([
+  "--backend",
+  "--presets",
+  "--brand",
+  "--domains",
+  "--kit",
+  "--marketplace",
+  "--medusa",
+  "--runtime",
+  "--themekit",
+  "--ui"
+]);
+var SWITCHES = new Set(["--check", "--help", "-h", "--no-install", "--plan"]);
+var OPTIONS = Object.fromEntries([
+  ...[...VALUED].map((flag) => [flag.slice(2), { type: "string" }]),
+  ...[...SWITCHES].filter((flag) => flag.startsWith("--")).map((flag) => [
+    flag.slice(2),
+    flag === "--help" ? { short: "h", type: "boolean" } : { type: "boolean" }
+  ])
+]);
+var parseArgs = (argv) => {
+  const { tokens } = readArgv({
+    allowPositionals: true,
+    args: [...argv],
+    options: OPTIONS,
+    strict: false,
+    tokens: true
+  });
+  for (const token of tokens) {
+    if (token.kind === "option" && !(token.name in OPTIONS)) {
+      throw new Error(`${token.rawName} is not an option create-geonosis takes. Run create-geonosis --help for the ones it does.`);
+    }
+  }
+  const { positionals, values } = readArgv({
+    allowPositionals: true,
+    args: [...argv],
+    options: OPTIONS,
+    strict: true
+  });
+  const flags = {};
+  for (const [name, value] of Object.entries(values)) {
+    if (typeof value === "string")
+      flags[`--${name}`] = value;
+    if (value === true)
+      flags[`--${name}`] = "true";
+  }
+  const [dir] = positionals;
+  return { ...dir === undefined ? {} : { dir }, flags };
+};
+var choose = (flag, given, allowed) => {
+  if (given === undefined) {
+    throw new Error(`${flag} is required — it is one of ${allowed.join(", ")}, and never a default`);
+  }
+  const chosen = allowed.find((one) => one === given);
+  if (chosen === undefined) {
+    throw new Error(`${flag} "${given}" is not one of ${allowed.join(", ")}`);
+  }
+  return chosen;
+};
+var scopeOf = (name) => `@${name.toLowerCase().replaceAll(/[^a-z0-9-]/g, "-")}`;
+var domainsFrom = (given) => {
+  const named = (given ?? "").split(",").map((one) => one.trim()).filter((one) => one !== "");
+  domainsNamed(named);
+  return named;
+};
+var parseAnswers = (argv, cwd) => {
+  const { dir, flags } = parseArgs(argv);
+  if (dir === undefined) {
+    throw new Error("create-geonosis needs a directory to write the repo into");
+  }
+  if (flags["--presets"] !== undefined) {
+    throw new Error("--presets is a --plan option: a scaffold takes its presets from --backend and --ui, and would ignore the ones named here");
+  }
+  const name = basename(resolve(cwd, dir));
+  const domains = domainsFrom(flags["--domains"]);
+  return {
+    backend: choose("--backend", flags["--backend"], BACKENDS),
+    ...flags["--brand"] === undefined ? {} : { brand: flags["--brand"] },
+    dir: resolve(cwd, dir),
+    domains,
+    ...flags["--kit"] === undefined ? {} : { kit: resolve(cwd, flags["--kit"]) },
+    ...flags["--marketplace"] === undefined ? {} : { marketplace: flags["--marketplace"] },
+    ...flags["--medusa"] === undefined ? {} : { medusa: flags["--medusa"] },
+    name,
+    runtime: choose("--runtime", flags["--runtime"], RUNTIMES),
+    scope: scopeOf(name),
+    ...flags["--themekit"] === undefined ? {} : { themekit: flags["--themekit"] },
+    ui: choose("--ui", flags["--ui"], UIS)
+  };
+};
+var wantsInstall = (argv) => !argv.includes("--no-install");
+export {
+  BACKENDS,
+  MEDUSA_PACKAGES,
+  MEDUSA_RANGE,
+  RUNTIMES,
+  UIS,
+  parseAnswers,
+  parseArgs,
+  scopeOf,
+  wantsInstall
+};

package/dist/check.d.ts

@@ -0,0 +1,24 @@
+import type { Answers } from './answers.js';
+/**
+ * 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.
+ */
+export type DriftKind = 'key' | 'missing' | 'unreadable';
+export 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.
+ */
+export declare const checkScaffold: (answers: Answers) => Drift[];
+export declare const describeDrift: (drift: readonly Drift[]) => string[];

package/dist/check.js

@@ -0,0 +1,62 @@
+// src/check.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PLATFORM_FILE } from "./composition.js";
+import { filesFor } from "./files.js";
+import { workspacesOf } from "./layout.js";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pathsIn = (value, prefix = "") => {
+  if (!isRecord(value))
+    return [];
+  return Object.entries(value).flatMap(([key, child]) => {
+    const here = prefix === "" ? key : `${prefix}.${key}`;
+    return [here, ...pathsIn(child, here)];
+  });
+};
+var parsed = (body) => {
+  try {
+    const value = JSON.parse(body);
+    return isRecord(value) ? value : undefined;
+  } catch {
+    return;
+  }
+};
+var missingPaths = (want, has) => {
+  const held = new Set(pathsIn(has));
+  return pathsIn(want).filter((path) => !held.has(path));
+};
+var isCompositionRoot = (file) => file.endsWith(`/${PLATFORM_FILE}`);
+var checkScaffold = (answers) => {
+  const drift = [];
+  const seeded = workspacesOf(answers).map((one) => `${one.dir}/`);
+  for (const [file, body] of Object.entries(filesFor(answers))) {
+    if (!isCompositionRoot(file) && seeded.some((prefix) => file.startsWith(prefix)))
+      continue;
+    const at = join(answers.dir, file);
+    if (!existsSync(at)) {
+      drift.push({ at: "", file, kind: "missing" });
+      continue;
+    }
+    const want = parsed(body);
+    if (want === undefined)
+      continue;
+    const has = parsed(readFileSync(at, "utf8"));
+    if (has === undefined) {
+      drift.push({ at: "", file, kind: "unreadable" });
+      continue;
+    }
+    for (const path of missingPaths(want, has))
+      drift.push({ at: path, file, kind: "key" });
+  }
+  return drift;
+};
+var SAID = {
+  key: (one) => `${one.file} → ${one.at} — the scaffold writes this key and your file has none`,
+  missing: (one) => `${one.file} — the scaffold writes this file and your repo has none`,
+  unreadable: (one) => `${one.file} — the scaffold writes plain JSON here and yours is not (comments? trailing commas?), so this check could not read its keys`
+};
+var describeDrift = (drift) => drift.map((one) => SAID[one.kind](one));
+export {
+  checkScaffold,
+  describeDrift
+};

package/dist/composition.d.ts

@@ -0,0 +1,46 @@
+/** Where the composition root lives, relative to the workspace that composes: the app. */
+export 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.
+ */
+export 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;
+};
+export declare const DOMAINS: readonly DomainScaffold[];
+export declare const DOMAIN_NAMES: readonly string[];
+/** The two foundations a composition root is built from, whichever domains it composes. */
+export declare const FOUNDATIONS: readonly {
+    at: string;
+    name: string;
+    version: string;
+}[];
+export declare const domainsNamed: (named: readonly string[]) => DomainScaffold[];
+/** What the composing workspace declares once a domain is named. */
+export declare const floorDependencies: (named: readonly string[]) => Record<string, string>;
+/** Every kit directory a `--kit` link has to reach for the domains this repo named. */
+export 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).
+ */
+export declare const platformSource: (named: readonly string[]) => string;

package/dist/composition.js

@@ -0,0 +1,137 @@
+// src/composition.ts
+import { FLOOR_VERSIONS } from "./floor-versions.js";
+var PLATFORM_FILE = "src/platform.ts";
+var SEARCH = {
+  at: "domains/search",
+  built: [
+    "      search: pgFtsSearchIndex({",
+    "        executor: tx,",
+    "        nowMs: definitions.nowMs,",
+    "        projections: SEARCH_PROJECTIONS,",
+    "      }),"
+  ],
+  declarations: [
+    "/** How each kind this repo indexes becomes searchable text — declared once, never per call. */",
+    "const SEARCH_PROJECTIONS: SearchProjections<'note'> = {",
+    "  note: {",
+    "    body: (fields) => fields.notes ?? '',",
+    "    title: (fields) => fields.heading ?? '',",
+    "  },",
+    "}"
+  ],
+  field: "search",
+  fieldType: "SearchIndex<'note'>",
+  imports: [
+    "import { pgFtsSearchIndex, type SearchIndex, type SearchProjections } from '@geonosis/search'"
+  ],
+  name: "@geonosis/search",
+  version: FLOOR_VERSIONS["@geonosis/search"]
+};
+var DOCUMENT = {
+  at: "domains/document",
+  built: ["      document: DOCUMENT_ENTITIES,"],
+  declarations: [
+    "/** Every `Document.extend` this repo declares, by the name its rows carry — grow this map. */",
+    "const DOCUMENT_ENTITIES = documentEntities({})"
+  ],
+  field: "document",
+  fieldType: "typeof DOCUMENT_ENTITIES",
+  imports: ["import { documentEntities } from '@geonosis/document'"],
+  name: "@geonosis/document",
+  version: FLOOR_VERSIONS["@geonosis/document"]
+};
+var DOMAINS = [SEARCH, DOCUMENT];
+var DOMAIN_NAMES = DOMAINS.map((one) => one.field);
+var FOUNDATIONS = [
+  { at: "foundations/db", name: "@geonosis/db", version: FLOOR_VERSIONS["@geonosis/db"] },
+  {
+    at: "foundations/events",
+    name: "@geonosis/events",
+    version: FLOOR_VERSIONS["@geonosis/events"]
+  }
+];
+var domainsNamed = (named) => named.map((one) => {
+  const found = DOMAINS.find((domain) => domain.field === one);
+  if (found === undefined) {
+    throw new Error(`--domains "${one}" is not a domain this kit ships — it ships ${DOMAIN_NAMES.join(", ")}. A domain nothing publishes cannot be composed, and a scaffold that wrote the import anyway would leave a repo that does not install.`);
+  }
+  return found;
+});
+var floorDependencies = (named) => named.length === 0 ? {} : Object.fromEntries([...FOUNDATIONS, ...domainsNamed(named)].map((one) => [one.name, `^${one.version}`]).toSorted(([a], [b]) => String(a).localeCompare(String(b), "en-US")));
+var floorDirectories = (named) => named.length === 0 ? [] : [...FOUNDATIONS, ...domainsNamed(named)].map((one) => one.at);
+var platformSource = (named) => {
+  const domains = domainsNamed(named);
+  return [
+    "import { createSessionSeam, type Executor, type SessionSeam } from '@geonosis/db'",
+    "import { createEmitDoor, type EmitDoor, type Extensions } from '@geonosis/events'",
+    ...domains.flatMap((one) => one.imports),
+    "",
+    "/** Every name a foundation cannot pick for this repo, answered here and only here. */",
+    "export type PlatformConfig = {",
+    "  newId: () => string",
+    "  nowMs: () => number",
+    "  /** What maintenance sets to see every tenant, through a lever no request path reaches. */",
+    "  opsSetting: string",
+    "  /** The producer every envelope names (D-057) — spelled here, never at an emit call. */",
+    "  source: string",
+    "  /** What a transaction sets to name its tenant, and what the RLS policies read. */",
+    "  tenantSetting: string",
+    "}",
+    "",
+    "export type Definitions = {",
+    "  emit: EmitDoor<Extensions>",
+    "  nowMs: () => number",
+    "  session: SessionSeam",
+    "}",
+    "",
+    "/** Once per isolate: what this platform is, before anybody has asked it anything. */",
+    "export const definitionsOf = (config: PlatformConfig): Definitions => ({",
+    "  emit: createEmitDoor({",
+    "    extensions: [],",
+    "    newId: config.newId,",
+    "    now: config.nowMs,",
+    "    source: config.source,",
+    "  }),",
+    "  nowMs: config.nowMs,",
+    "  session: createSessionSeam({",
+    "    settings: { opsSetting: config.opsSetting, tenantSetting: config.tenantSetting },",
+    "  }),",
+    "})",
+    "",
+    ...domains.flatMap((one) => [...one.declarations, ""]),
+    "/** Who is asking, and the connection they may ask on. */",
+    "export type Caller = { connection: Executor; tenantId: string }",
+    "",
+    "/** Every domain this repo composed, built for one caller. */",
+    "export type Scope = {",
+    ...domains.map((one) => `  ${one.field}: ${one.fieldType}`),
+    "}",
+    "",
+    "/**",
+    " * Per request. The tenant session opens FIRST and the stores are built inside it, so a store",
+    " * that could run outside the transaction that named its tenant does not exist to be held.",
+    " */",
+    "export const inScope = async <Result>(",
+    "  definitions: Definitions,",
+    "  caller: Caller,",
+    "  run: (scope: Scope) => Promise<Result>,",
+    "): Promise<Result> =>",
+    "  definitions.session.inTenant(caller.connection, caller.tenantId, async (tx) =>",
+    "    run({",
+    ...domains.flatMap((one) => [...one.built]),
+    "    }),",
+    "  )",
+    ""
+  ].join(`
+`);
+};
+export {
+  DOMAINS,
+  DOMAIN_NAMES,
+  FOUNDATIONS,
+  PLATFORM_FILE,
+  domainsNamed,
+  floorDependencies,
+  floorDirectories,
+  platformSource
+};

package/dist/corpus.d.ts

@@ -0,0 +1,16 @@
+import type { Answers } from './answers.js';
+import type { Workspace } from './layout.js';
+export 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.
+ */
+export declare const corpusFor: (answers: Answers, workspaces: Workspace[]) => Record<string, string>;

package/dist/corpus.js

@@ -0,0 +1,46 @@
+// src/corpus.ts
+var CORPUS_DIR = "lint-corpus";
+var PREFIX = "biological-architecture";
+var corpusFor = (answers, workspaces) => {
+  const files = {};
+  const rules = [];
+  const walled = workspaces.find((one) => one.mayDependOn.length === 0);
+  const forbidden = workspaces.find((one) => one.tag === "app");
+  if (walled !== undefined && forbidden !== undefined) {
+    rules.push(`${PREFIX}/layer-walls`);
+    files[`${CORPUS_DIR}/${walled.dir}/src/bad-reaches-up.ts`] = `// BREACH: the ${walled.tag} layer may import nothing, and this reaches ${forbidden.tag}.
+import { boot } from '${forbidden.name}/boot'
+
+export const reachesUp = () => boot
+`;
+  }
+  if (answers.brand !== undefined) {
+    rules.push(`${PREFIX}/no-brand-names`);
+    files[`${CORPUS_DIR}/brand/bad-brand.ts`] = `// BREACH: the brand name spelled into source, which is what the rule is configured to find.
+export const FOOTER_NOTE = 'Powered by ${answers.brand}'
+`;
+  }
+  if (answers.backend === "medusa") {
+    rules.push(`${PREFIX}/plugin-route-namespaced`);
+    files[`${CORPUS_DIR}/packages/medusa-plugins/example/src/api/store/route.ts`] = `// BREACH: a store route with no namespace under it, in a plugin package.
+export async function GET(req: unknown, res: { json: (body: unknown) => void }) {
+  res.json({ ok: true, req })
+}
+`;
+  }
+  if (answers.backend === "sagaflow-cf") {
+    rules.push(`${PREFIX}/step-opens-its-own-cell`);
+    files[`${CORPUS_DIR}/packages/backend/src/workflows/bad-engine-step.ts`] = `// BREACH: a saga inside the configured \`within\` reaching the engine's own step.
+import { step } from 'sagaflow-js'
+
+export const issue = step('issue', async () => ({ ok: true }))
+`;
+  }
+  files[`${CORPUS_DIR}/manifest.json`] = `${JSON.stringify({ plugin: PREFIX, rules }, undefined, 2)}
+`;
+  return files;
+};
+export {
+  CORPUS_DIR,
+  corpusFor
+};