create-geonosis 2.12.0 → 3.0.0

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
+};

package/dist/create-geonosis-cli.js

@@ -1,199 +1,15 @@
-import {
-  BACKENDS,
-  DOMAIN_NAMES,
-  MEDUSA_RANGE,
-  PLATFORM_FILE,
-  UIS,
-  checkScaffold,
-  describeDrift,
-  finish,
-  parseAnswers,
-  parseArgs,
-  scopeOf,
-  wantsInstall,
-  writeScaffold
-} from "./chunk-4IX6PJ7R.js";
-
-// src/create-geonosis-cli.ts
-import { existsSync as existsSync2 } from "fs";
-
-// src/adopt.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { basename, join, resolve } from "path";
-import { countersFor, rulesFor, runtimeOf, tiersFor } from "@geonosis/cli";
-var ADOPT_USAGE = "create-geonosis --plan <dir> [--presets <a,b>] [--runtime pnpm|bun] [--backend medusa|sagaflow-cf|none] [--ui tiered-shadcn|atoms-only|none] \u2014 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 void 0;
-  try {
-    return JSON.parse(readFileSync(at, "utf8"));
-  } catch {
-    return void 0;
-  }
-};
-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 !== void 0);
-};
-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 === void 0) return void 0;
-  if (!allowed.includes(given)) {
-    throw new Error(`${flag} "${given}" is not one of ${allowed.join(", ")}`);
-  }
-  return given;
-};
-var uiOf = (dir, given) => {
-  if (given !== void 0) return given;
-  if (!existsSync(join(dir, "packages/ui"))) return "none";
-  throw new Error(
-    `${dir} has a packages/ui and no --ui was given \u2014 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 \u2014 --plan reads a repo, it never makes one`);
-  const manifests = manifestsIn(at);
-  const chosenRuntime = chosen("--runtime", runtime, ["bun", "pnpm"]) ?? runtimeOf(at);
-  if (chosenRuntime === void 0) {
-    throw new Error(
-      `${at} has none of ${LOCKFILES.join(", ")}, so nothing there says which package manager it runs \u2014 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} \u2014 none`, ""] : [`${title} (${lines.length})`, ...lines, ""];
-var formatPlan = (plan) => [
-  `adoption plan for ${plan.dir}`,
-  `  runtime ${plan.runtime} \xB7 backend ${plan.backend} \xB7 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} \u2192 ${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 ? " \u2014 declared" : ""}`)
-  ),
-  ...section(
-    "TIERS",
-    plan.tiers.map((one) => `  ${one.name}${one.declared ? " \u2014 declared" : ""}`)
-  ),
-  ...section(
-    "DOORS a block needs declared",
-    plan.doors.map(
-      (one) => `  ${one.package} for "${one.block}"${one.declared ? " \u2014 declared" : ""}`
-    )
-  ),
-  ...plan.unreadable.length === 0 ? [] : section(
-    "FILES this check could not read as JSON",
-    plan.unreadable.map((one) => `  ${one.file}`)
-  )
-].join("\n");
-
 // src/create-geonosis-cli.ts
+import { existsSync } from "node:fs";
+import { ADOPT_USAGE, formatPlan, planAdoption } from "./adopt.js";
+import { MEDUSA_RANGE, parseAnswers, parseArgs, wantsInstall } from "./answers.js";
+import { checkScaffold, describeDrift } from "./check.js";
+import { DOMAIN_NAMES, PLATFORM_FILE } from "./composition.js";
+import { finish, writeScaffold } from "./scaffold.js";
 var USAGE = `create-geonosis <dir> --runtime pnpm|bun --backend medusa|sagaflow-cf|none --ui tiered-shadcn|atoms-only|none
                 [--medusa <range>]
                 [--domains <a,b>] [--brand <name>] [--themekit <name>] [--marketplace <path>] [--kit <path>] [--no-install]
                 [--check]
-create-geonosis --plan <dir> [--presets <a,b>] [--runtime \u2026] [--backend \u2026] [--ui \u2026]
+create-geonosis --plan <dir> [--presets <a,b>] [--runtime …] [--backend …] [--ui …]
 
 Writes a repo that passes its own gates on day one: a workspace with one catalog of shared versions,
 an exports map and no barrel in every package, typecheck + lint + test scripts in every workspace,
@@ -204,7 +20,7 @@ skills lock, and a reach corpus in this repo's own vocabulary so the doctor can
 There is no default for --runtime, --backend or --ui. Each one decides the shape of the tree, and a
 default borrowed from another repo would be that repo's stack hardcoded into this one.
 
-  --domains      the domains this repo composes \u2014 ${DOMAIN_NAMES.join(", ")}. Each one writes its
+  --domains      the domains this repo composes — ${DOMAIN_NAMES.join(", ")}. Each one writes its
                  store into the app's ${PLATFORM_FILE}: the composition root, in two lifetimes, with
                  the tenant session opened before any store is built. A name nothing ships is refused.
   --medusa <range>
@@ -221,19 +37,19 @@ default borrowed from another repo would be that repo's stack hardcoded into thi
                  preset brings against the ones already enabled, the rules left out until somebody
                  answers their option, the counters, the tiers and the doors a block needs
                  declared. The runtime and the backend are read off the lockfile and the manifests;
-                 a flag overrides one. Exit 0 \u2014 it is a report.
+                 a flag overrides one. Exit 0 — it is a report.
   --check        say what an EXISTING repo is missing of what the scaffold writes today, and WRITE
                  NOTHING. Files it has never had, and keys inside the JSON it has. Contents and
                  values are never compared: a repo that has been worked in has rewritten them, and
                  it was entitled to. Exit 1 when anything drifted.
 
-Exit: 0 written (or, under --check, no drift) \xB7 1 refused (a directory with something in it, an
-answer that is not one) or drift found \xB7 2 a run that could not be made at all.`;
+Exit: 0 written (or, under --check, no drift) · 1 refused (a directory with something in it, an
+answer that is not one) or drift found · 2 a run that could not be made at all.`;
 var CONFIG_SHAPE = `create-geonosis reads no configuration file.
 
 It WRITES them: geonosis.json, .oxlintrc.json, geonosis.ratchet.json and gate-baseline.json, from
 the answers given on the command line. Every answer is a flag, and there is no default for the three
-that decide the shape of the tree \u2014 see create-geonosis --help.
+that decide the shape of the tree — see create-geonosis --help.
 
 For the shape of what it wrote, ask the bin that reads it: geonosis-<tool> --print-config-shape.`;
 var main = () => {
@@ -250,61 +66,57 @@ var main = () => {
   }
   if (argv.includes("--plan")) {
     const { dir, flags } = parseArgs(argv);
-    if (dir === void 0) throw new Error(`--plan needs a directory \u2014 ${ADOPT_USAGE}`);
-    process.stdout.write(
-      `${formatPlan(
-        planAdoption({
-          ...flags["--backend"] === void 0 ? {} : { backend: flags["--backend"] },
-          dir,
-          presets: (flags["--presets"] ?? "frontend,tooling").split(",").map((one) => one.trim()).filter((one) => one !== ""),
-          ...flags["--runtime"] === void 0 ? {} : { runtime: flags["--runtime"] },
-          ...flags["--ui"] === void 0 ? {} : { ui: flags["--ui"] }
-        })
-      )}
-`
-    );
+    if (dir === undefined)
+      throw new Error(`--plan needs a directory — ${ADOPT_USAGE}`);
+    process.stdout.write(`${formatPlan(planAdoption({
+      ...flags["--backend"] === undefined ? {} : { backend: flags["--backend"] },
+      dir,
+      presets: (flags["--presets"] ?? "frontend,tooling").split(",").map((one) => one.trim()).filter((one) => one !== ""),
+      ...flags["--runtime"] === undefined ? {} : { runtime: flags["--runtime"] },
+      ...flags["--ui"] === undefined ? {} : { ui: flags["--ui"] }
+    }))}
+`);
     return 0;
   }
   const answers = parseAnswers(argv, process.cwd());
   if (argv.includes("--check")) {
-    if (!existsSync2(answers.dir)) {
-      throw new Error(`${answers.dir} is not there \u2014 --check reads a repo, it never makes one`);
+    if (!existsSync(answers.dir)) {
+      throw new Error(`${answers.dir} is not there — --check reads a repo, it never makes one`);
     }
     const drift = checkScaffold(answers);
     if (drift.length === 0) {
-      process.stdout.write(`create-geonosis --check ${answers.dir} \u2014 no drift
+      process.stdout.write(`create-geonosis --check ${answers.dir} — no drift
 `);
       return 0;
     }
-    for (const line of describeDrift(drift)) process.stderr.write(`  ${line}
+    for (const line of describeDrift(drift))
+      process.stderr.write(`  ${line}
+`);
+    process.stderr.write(`create-geonosis --check ${answers.dir} — ${drift.length} drift, nothing written
 `);
-    process.stderr.write(
-      `create-geonosis --check ${answers.dir} \u2014 ${drift.length} drift, nothing written
-`
-    );
     return 1;
   }
   const written = writeScaffold(answers);
-  process.stdout.write(`create-geonosis \u2014 ${written.length} file(s) into ${answers.dir}
+  process.stdout.write(`create-geonosis — ${written.length} file(s) into ${answers.dir}
 `);
   const install = wantsInstall(argv);
   for (const step of finish({ answers, install })) {
     process.stdout.write(`  ${step.code === 0 ? "ok  " : "FAIL"}  ${step.what}
 `);
-    if (step.code !== 0) process.stdout.write(`${step.output}
+    if (step.code !== 0)
+      process.stdout.write(`${step.output}
 `);
   }
   if (!install) {
-    process.stdout.write(
-      [
-        "",
-        "  Nothing was installed, so the edges table has not reached the gates yet. Run:",
-        `    cd ${answers.dir} && ${answers.runtime} install`,
-        "    geonosis sync --target turbo --into turbo.json",
-        "    geonosis sync --target layer-walls --into .oxlintrc.json",
-        ""
-      ].join("\n")
-    );
+    process.stdout.write([
+      "",
+      "  Nothing was installed, so the edges table has not reached the gates yet. Run:",
+      `    cd ${answers.dir} && ${answers.runtime} install`,
+      "    geonosis sync --target turbo --into turbo.json",
+      "    geonosis sync --target layer-walls --into .oxlintrc.json",
+      ""
+    ].join(`
+`));
   }
   return 0;
 };

package/dist/files.d.ts

@@ -0,0 +1,18 @@
+import type { Answers } from './answers.js';
+declare const presetsFor: (answers: Answers) => string[];
+/** The kit a scaffolded repo runs on, at the version this scaffold was published at. */
+export declare const kitDependencies: (answers: Answers) => Record<string, string>;
+/**
+ * The two files the edges table generates, named once. `scaffold` runs them when it makes the tree
+ * and the `sync:graph` script runs them when the table changes; a second spelling of the pair is a
+ * second answer to where the graph comes from.
+ */
+export declare const GRAPH_SYNCS: {
+    target: string;
+    write: string;
+}[];
+/** What the root can be asked to run — and therefore what a verify tier may name (`tiersFor`). */
+export declare const HOOK_INSTALLER = "scripts/install-hooks.mjs";
+export declare const filesFor: (answers: Answers) => Record<string, string>;
+export declare const presetsChosenBy: typeof presetsFor;
+export {};