create-nola-lang 0.1.13 → 0.1.15

package/dist/flow.js

@@ -16,9 +16,9 @@ import { acquireKey, SignInRequiredError } from "./key.js";
 import { realLauncher } from "./launch.js";
 import { nodeVersionWarning } from "./node-version.js";
 import { openBrowser } from "./open-url.js";
-import { detectPackageManager, packageManagerCommands } from "./package-manager.js";
+import { defaultRuntime, detectPackageManager, isRuntime, packageManagerCommands } from "./package-manager.js";
 import { isProviderId, PROVIDERS, providerById, providerIds } from "./providers.js";
-import { entryFile, exampleNames, featuredNames, TEMPLATES, templateByName, templateNames } from "./registry.js";
+import { entryFile, exampleNames, featuredNames, templateByName, templateNames } from "./registry.js";
 import { ownVersion, scaffold, vendorEnvVar } from "./scaffold.js";
 import { applyTrial } from "./trial.js";
 const DEFAULT_DIR = "nola-app";
@@ -62,9 +62,10 @@ function templateOption(t) {
 /*
  * The template step is TWO menus (clack's select has no sections): the first
  * lists the first-menu templates — feature-extraction, function-calling,
- * typescript-interop, triage-ticket (the featured example), empty — and one
- * "More examples…" row; that row opens the remaining curated examples, with a
- * Back row to return. `--template <name>` answers either level directly.
+ * agent-loop, typescript-interop, triage-ticket (the featured examples),
+ * empty (the one builtin) — and one "More examples…" row; that row opens the
+ * remaining curated examples, with a Back row to return. `--template <name>`
+ * answers either level directly.
  */
 export const TEMPLATE_QUESTION = "Select a template:";
 export const EXAMPLE_QUESTION = "Select an example:";
@@ -72,11 +73,7 @@ export const EXAMPLE_QUESTION = "Select an example:";
 export const MORE_EXAMPLES = "more-examples";
 /** the examples menu's last row — back to the first menu */
 export const BACK = "back";
-/** `"feature-extraction", "function-calling", …` — for the fetch-failure note. */
-const builtinNames = () => TEMPLATES.filter((t) => t.source === "builtin")
-    .map((t) => `"${t.name}"`)
-    .join(", ");
-/** The first menu: the builtin templates and the featured example in registry order, then the examples row. */
+/** The first menu: the featured examples and `empty` in registry order, then the examples row. */
 export function templateMenu() {
     const featured = featuredNames().map((name) => templateOption(templateByName(name)));
     return [...featured, { value: MORE_EXAMPLES, label: "More examples…", hint: exampleNames().join(", ") }];
@@ -84,8 +81,14 @@ export function templateMenu() {
 /** The second menu: the curated examples the first menu does not carry, in registry order, then Back. */
 export function exampleMenu() {
     const examples = exampleNames().map((name) => templateOption(templateByName(name)));
-    return [...examples, { value: BACK, label: "← Back", hint: "the builtin templates" }];
+    return [...examples, { value: BACK, label: "← Back", hint: "the first menu" }];
 }
+/**
+ * The note a failed example fetch gets (interactive: the menu is asked
+ * again). Only `empty` ships inside the CLI; every other template is fetched
+ * from GitHub, so an offline machine can still scaffold that one.
+ */
+export const FETCH_FAILURE_HINT = 'Only "empty" ships inside the CLI and needs no download — every other template is fetched from GitHub.';
 /** Ask the two-level template menu until a template is chosen; null = cancelled. */
 async function selectTemplate(prompter) {
     for (;;) {
@@ -227,13 +230,22 @@ async function resolveProvider(input, prompter, template) {
         return choice;
     }
 }
+/** `--runtime`, else the manager's default (bun → bun). Validated up front like the other flags. */
+function resolveRuntime(input) {
+    if (input.runtime !== undefined) {
+        if (!isRuntime(input.runtime))
+            throw new Error(`invalid --runtime "${input.runtime}" (valid: node, bun)`);
+        return input.runtime;
+    }
+    return defaultRuntime(input.packageManager ?? "npm");
+}
 /** The provider and setup (editor + agents) questions, in that order, shared by every outcome site; null = cancelled. */
 async function resolveExtras(input, prompter, dir, template) {
     const provider = await resolveProvider(input, prompter, template);
     if (provider === null)
         return null;
     const setup = await resolveSetup(input, prompter, dir);
-    return setup === null ? null : { provider, ...setup };
+    return setup === null ? null : { provider, ...setup, runtime: resolveRuntime(input) };
 }
 /** Args fill prompts; whatever is missing is asked (never asked non-interactively). */
 export async function resolveScaffoldOptions(input, prompter) {
@@ -243,6 +255,9 @@ export async function resolveScaffoldOptions(input, prompter) {
     if (input.ide !== undefined && input.ide !== "vscode" && input.ide !== "none") {
         throw new Error(`invalid --ide "${input.ide}" (valid: vscode, none)`);
     }
+    if (input.runtime !== undefined && !isRuntime(input.runtime)) {
+        throw new Error(`invalid --runtime "${input.runtime}" (valid: node, bun)`);
+    }
     if (input.agents !== undefined)
         parseAgentsFlag(input.agents); // throws on unknown ids
     flaggedProvider(input); // throws on an unknown id or a contradiction
@@ -370,10 +385,14 @@ export function plainPrompter() {
 export const FLOW_OPTIONS = {
     template: {
         type: "string",
-        description: "template to scaffold (feature-extraction, function-calling, typescript-interop, empty, or a curated example)",
+        description: "template to scaffold: feature-extraction (the default), function-calling, agent-loop, typescript-interop, triage-ticket, empty, or another curated example",
     },
     add: { type: "boolean", description: "add Nola to the existing project in [dir] instead of scaffolding" },
     ide: { type: "string", description: "editor setup: vscode (the default) | none" },
+    runtime: {
+        type: "string",
+        description: "runtime the project runs on: node | bun (default: bun when bun ran the scaffolder — bunfig.toml preload + `bun src/main.tsi`)",
+    },
     agents: {
         type: "string",
         description: `agent skill files: ${AGENT_IDS.join(",")} | all | none (default: claude,universal)`,
@@ -593,6 +612,8 @@ export async function runFlow(args, opts = {}) {
         agents: args.agents,
         provider: args.provider,
         trial: args.trial,
+        runtime: args.runtime,
+        packageManager: pm,
         keyPath,
         signIn: signInNow,
         cwd: opts.cwd,
@@ -606,7 +627,7 @@ export async function runFlow(args, opts = {}) {
         }
         if (outcome.kind === "add") {
             const grant = outcome.provider === "nola" ? await obtainTrial(prompter, opts, interactive) : null;
-            const result = await addNola(outcome.dir, { provider: outcome.provider });
+            const result = await addNola(outcome.dir, { provider: outcome.provider, runtime: outcome.runtime });
             const trial = grant
                 ? await applyTrial(outcome.dir, { apiKey: grant.apiKey, hasConfig: !result.wrote.includes("nola.config.ts") })
                 : { wrote: [], skipped: [] };
@@ -626,7 +647,12 @@ export async function runFlow(args, opts = {}) {
             }
             const lines = [
                 packageManagerCommands(pm).install,
-                'optional start script:  "start": "nola run src/main.ts"',
+                ...(outcome.runtime === "bun"
+                    ? [
+                        'bunfig.toml: preload = ["@nola-lang/bun/preload"] (runs .tsi from source under Bun)',
+                        'optional start script:  "start": "bun src/main.ts"',
+                    ]
+                    : ['optional start script:  "start": "nola run src/main.ts"']),
                 'tsconfig tip: directory-style include (e.g. ["src"]) lets the editor see .tsi files',
                 commented(CONSOLE_COMMAND, CONSOLE_NOTE),
             ];
@@ -641,7 +667,13 @@ export async function runFlow(args, opts = {}) {
             const grant = outcome.provider === "nola" ? await obtainTrial(prompter, opts, interactive) : null;
             // A nola choice without a key (declined sign-in, API failure) scaffolds the plain template — the note above says why.
             const provider = outcome.provider === "nola" ? (grant ? "nola" : "none") : outcome.provider;
-            const { files } = await scaffold(outcome.dir, { template: outcome.template, force: outcome.force, provider, ide: outcome.ide });
+            const { files } = await scaffold(outcome.dir, {
+                template: outcome.template,
+                force: outcome.force,
+                provider,
+                ide: outcome.ide,
+                runtime: outcome.runtime,
+            });
             let trialWrote = [];
             if (grant) {
                 const trial = await applyTrial(outcome.dir, { apiKey: grant.apiKey, hasConfig: false });
@@ -675,7 +707,7 @@ export async function runFlow(args, opts = {}) {
         }
         catch (err) {
             if (err instanceof ExampleFetchError && interactive) {
-                prompter.note(`${err.message}\nThe builtin templates (${builtinNames()}) work offline.`);
+                prompter.note(`${err.message}\n${FETCH_FAILURE_HINT}`);
                 input.dir = outcome.dir; // keep the chosen dir, re-pick the template
                 input.template = undefined;
                 continue;

package/dist/github.d.ts

@@ -1,4 +1,4 @@
-/** Network/acquisition failure — the builtin templates always work offline. */
+/** Network/acquisition failure — `empty`, the one builtin template, always works offline. */
 export declare class ExampleFetchError extends Error {
 }
 export type FetchLike = (url: string) => Promise<{

package/dist/github.js

@@ -1,6 +1,6 @@
 /** Production example acquisition: GitHub Trees API + raw file fetches. */
 const REPO = "nola-lang/nola";
-/** Network/acquisition failure — the builtin templates always work offline. */
+/** Network/acquisition failure — `empty`, the one builtin template, always works offline. */
 export class ExampleFetchError extends Error {
 }
 /** Try the lockstep release tag first; a repo without that tag serves main. */

package/dist/index.js

@@ -87,7 +87,7 @@ import {
   writeEnvKey,
   writeSession,
   writeVscodeSetup
-} from "./chunk-LUSVIOAN.js";
+} from "./chunk-UTVGG44K.js";
 import {
   clackPrompter
 } from "./chunk-7IQIRMK6.js";

package/dist/launch.d.ts

@@ -17,7 +17,7 @@ export interface Launcher {
     /**
      * `code <dir> [<dir>/<entry>]`, detached; "not-found" when VS Code's `code`
      * command is not on PATH. `entry` is a project-relative file to open as the
-     * active editor on top of the folder (the scaffold's src/main.ts).
+     * active editor on top of the folder (the template's entry file).
      */
     openVscode(dir: string, entry?: string): Promise<"opened" | "not-found">;
 }
@@ -25,7 +25,7 @@ export interface Launcher {
  * The arguments that open a project in VS Code: the folder alone, or the
  * folder plus one file. `code <folder> <file>` opens the folder as the
  * workspace and the file as the active editor — that is how the scaffold
- * lands the user on src/main.ts instead of an empty window.
+ * lands the user on the entry file instead of an empty window.
  */
 export declare function vscodeArgs(dir: string, entry?: string): string[];
 /**

package/dist/launch.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
  * The arguments that open a project in VS Code: the folder alone, or the
  * folder plus one file. `code <folder> <file>` opens the folder as the
  * workspace and the file as the active editor — that is how the scaffold
- * lands the user on src/main.ts instead of an empty window.
+ * lands the user on the entry file instead of an empty window.
  */
 export function vscodeArgs(dir, entry) {
     return entry === undefined ? [dir] : [dir, join(dir, entry)];

package/dist/main.js

@@ -3,7 +3,7 @@ import {
   CREATE_COMMAND,
   dispatch,
   ownVersion
-} from "./chunk-LUSVIOAN.js";
+} from "./chunk-UTVGG44K.js";
 import "./chunk-FPS2V3S4.js";
 
 // src/main.ts

package/dist/node-version.d.ts

@@ -1,6 +1,7 @@
 /**
- * The Node floor the docs state. Plain `.ts` (the templates' `src/main.ts`)
- * is loaded by Node's native type stripping, which is on by default only from
+ * The Node floor the docs state. Plain `.ts` (an example's `src/main.ts`, or the
+ * plain modules a `.tsi` entry imports) is loaded by Node's native type
+ * stripping, which is on by default only from
  * 22.18 on the 22 line and 23.6 on the 23 line; before that it sits behind
  * `--experimental-strip-types` and the default loader rejects `.ts` outright
  * (ERR_UNKNOWN_FILE_EXTENSION) — `npm start` and the F5 launch both die on

package/dist/node-version.js

@@ -1,6 +1,7 @@
 /**
- * The Node floor the docs state. Plain `.ts` (the templates' `src/main.ts`)
- * is loaded by Node's native type stripping, which is on by default only from
+ * The Node floor the docs state. Plain `.ts` (an example's `src/main.ts`, or the
+ * plain modules a `.tsi` entry imports) is loaded by Node's native type
+ * stripping, which is on by default only from
  * 22.18 on the 22 line and 23.6 on the 23 line; before that it sits behind
  * `--experimental-strip-types` and the default loader rejects `.ts` outright
  * (ERR_UNKNOWN_FILE_EXTENSION) — `npm start` and the F5 launch both die on
@@ -47,7 +48,7 @@ export function nodeVersionWarning(version = process.versions.node) {
         return undefined;
     const lines = [
         `Node ${version} is older than Nola needs: Node >= ${NODE_FLOOR}, the first release that runs .ts files natively.`,
-        "On this Node, `npm start` and the VS Code F5 launch fail with ERR_UNKNOWN_FILE_EXTENSION for src/main.ts.",
+        "On this Node, `npm start` and the VS Code F5 launch fail with ERR_UNKNOWN_FILE_EXTENSION on the first plain .ts file they load.",
     ];
     if (hasStripTypesFlag(version)) {
         lines.push("Upgrade Node (recommended), or set NODE_OPTIONS=--experimental-strip-types for `npm start` and add", '"--experimental-strip-types" to runtimeArgs in .vscode/launch.json.');

package/dist/package-manager.d.ts

@@ -14,4 +14,9 @@ export interface PackageManagerCommands {
     run: string;
 }
 export declare function packageManagerCommands(pm: PackageManager): PackageManagerCommands;
+/** The runtime a scaffold targets: Node (the loader, `nola run`) or Bun (`@nola-lang/bun`'s preload, `bun src/main.tsi`). */
+export type Runtime = "node" | "bun";
+export declare function isRuntime(value: string): value is Runtime;
+/** `bun create nola` produces a Bun project unless `--runtime node` says otherwise; every other manager scaffolds for Node. */
+export declare function defaultRuntime(pm: PackageManager): Runtime;
 //# sourceMappingURL=package-manager.d.ts.map

package/dist/package-manager.js

@@ -5,4 +5,11 @@ export function detectPackageManager(userAgent = process.env.npm_config_user_age
 export function packageManagerCommands(pm) {
     return { install: `${pm} install`, start: `${pm} start`, run: `${pm} run` };
 }
+export function isRuntime(value) {
+    return value === "node" || value === "bun";
+}
+/** `bun create nola` produces a Bun project unless `--runtime node` says otherwise; every other manager scaffolds for Node. */
+export function defaultRuntime(pm) {
+    return pm === "bun" ? "bun" : "node";
+}
 //# sourceMappingURL=package-manager.js.map

package/dist/providers.d.ts

@@ -4,7 +4,7 @@
  * template registry: `nola` is the platform, labelled "nola: dev" so the row
  * reads as a mode of the project rather than a fourth vendor (the free trial, or a key on the
  * account — see `keyPath`), the four vendors write a bring-your-own config,
- * `none` is the offline default (the builtin templates replay their ledgers). typesafe.ai
+ * `none` is the offline default (the template's own config: a recorded ledger or a mock). typesafe.ai
  * serves literal unions and booleans only; it is listed for every template all
  * the same, and `providerOptions` (flow.ts) brackets that caveat into its hint.
  */

package/dist/providers.js

@@ -10,7 +10,7 @@ export const PROVIDERS = [
     },
     { id: "google", label: "Gemini", hint: 'google("gemini-2.5-flash"), reads GEMINI_API_KEY', envVar: "GEMINI_API_KEY", model: 'google("gemini-2.5-flash")' },
     { id: "typesafe", label: "typesafe.ai", hint: "typesafe(), reads TYPESAFE_API_KEY", envVar: "TYPESAFE_API_KEY", model: "typesafe()" },
-    { id: "none", label: "Skip for now", hint: "the builtin templates run offline from a replay ledger; pick a model in nola.config.ts later" },
+    { id: "none", label: "Skip for now", hint: "keeps the template's own config (the recorded ones run offline); pick a model in nola.config.ts later" },
 ];
 export function providerById(id) {
     return PROVIDERS.find((p) => p.id === id);

package/dist/registry.d.ts

@@ -2,31 +2,40 @@
  * The template menu. Static by design: it is versioned in lockstep with the
  * git tag the example fetcher pulls from, so names and labels cannot drift.
  *
+ * `empty` is the ONLY builtin template (config + tsconfig + a stub entry,
+ * shipped inside this package). Every other template IS a curated example:
+ * its files come from `examples/` — on disk in a dev checkout, from GitHub
+ * (the lockstep release tag) in production — and the scaffolder adds the
+ * project name, the lockstep ranges, the recommended `.gitignore`, the
+ * chosen provider's config and the next-steps comment on top.
+ *
  * The first menu leads (in this order) and is organized BY FEATURE:
- * `feature-extraction` (the default) and `function-calling` are each one
- * `.tsi` file with a top-level ask — the two things Nola does —
+ * `feature-extraction` (the default), `function-calling` and `tool-use` are
+ * each one `.tsi` file with a top-level ask — the three things Nola does —
+ * `agent-loop` is the same shape around a top-level `while`,
  * `typescript-interop` is the infer-function shape called from plain
- * TypeScript, `triage-ticket` (a FEATURED example: fetched from examples/
- * like the rest, listed here because it is the one-file shape on a
- * non-chat vendor) and `empty`. The other curated examples follow (behind
- * "More examples…"). extract-person is deliberately absent —
- * typescript-interop IS extract-person plus the replay ledger.
+ * TypeScript, `triage-ticket` the one-file shape on a non-chat vendor, then
+ * `empty` (a stub `src/main.tsi` to write your own in). The other curated
+ * examples follow (behind "More examples…").
+ * extract-person is deliberately absent — typescript-interop IS
+ * extract-person plus the replay ledger.
  */
 export interface TemplateDef {
     name: string;
     /** one-line menu description */
     label: string;
+    /** where the files come from: this package's `templates/` dir, or `examples/` */
     source: "builtin" | "example";
     /**
-     * An example listed on the FIRST menu, in registry order beside the
-     * builtin templates, instead of behind "More examples…". Its files still
-     * come from examples/ (`source` is unchanged).
+     * An example listed on the FIRST menu, in registry order beside `empty`,
+     * instead of behind "More examples…". Its files still come from examples/
+     * (`source` is unchanged).
      */
     featured?: true;
     /**
      * The file that IS the program — what `start` runs, launch.json's
      * `program`, what VS Code opens, where the next-steps comment lands.
-     * Absent = the plain-TS `src/main.ts` every other template has.
+     * Absent = the plain-TS `src/main.ts` the other examples have.
      */
     entry?: string;
     /**
@@ -43,7 +52,7 @@ export interface TemplateDef {
 /** What a template runs unless it names its own entry: the plain-TS main. */
 export declare const DEFAULT_ENTRY = "src/main.ts";
 export declare const TEMPLATES: readonly TemplateDef[];
-/** The first menu's templates: the builtins and the featured example, in registry order. */
+/** The first menu's templates: the featured examples and `empty`, in registry order. */
 export declare function featuredNames(): string[];
 /** The examples behind "More examples…": every example the first menu does not carry. */
 export declare function exampleNames(): string[];

package/dist/registry.js

@@ -1,17 +1,39 @@
 /** What a template runs unless it names its own entry: the plain-TS main. */
 export const DEFAULT_ENTRY = "src/main.ts";
 export const TEMPLATES = [
-    { name: "feature-extraction", label: "extract typed data from context", source: "builtin", entry: "src/main.tsi" },
+    {
+        name: "feature-extraction",
+        label: "extract typed data from context",
+        source: "example",
+        featured: true,
+        entry: "src/main.tsi",
+    },
     {
         name: "function-calling",
         label: "call an async function from a TypeScript file",
-        source: "builtin",
+        source: "example",
+        featured: true,
+        entry: "src/main.tsi",
+    },
+    {
+        name: "tool-use",
+        label: "offer functions as tools: the model calls them as it needs before it answers",
+        source: "example",
+        featured: true,
+        entry: "src/main.tsi",
+    },
+    {
+        name: "agent-loop",
+        label: "an agent loop in one .tsi file: a top-level while with an ask, and a context statement read on every pass",
+        source: "example",
+        featured: true,
         entry: "src/main.tsi",
     },
     {
         name: "typescript-interop",
         label: "an infer function example, imported and awaited from plain TypeScript",
-        source: "builtin",
+        source: "example",
+        featured: true,
     },
     {
         name: "triage-ticket",
@@ -21,7 +43,7 @@ export const TEMPLATES = [
         entry: "src/main.tsi",
         provider: { label: "typesafe.ai", envVar: "TYPESAFE_API_KEY" },
     },
-    { name: "empty", label: "nola.config + tsconfig only, bring your own code", source: "builtin" },
+    { name: "empty", label: "nola.config + tsconfig only, bring your own code", source: "builtin", entry: "src/main.tsi" },
     { name: "file-ticket", label: "call intents: the model fills a function's arguments", source: "example" },
     { name: "extract-resume", label: "nested arrays of objects, JSDoc schema descriptions", source: "example" },
     { name: "extract-invoice", label: "same-file type references, optional fields", source: "example" },
@@ -29,7 +51,7 @@ export const TEMPLATES = [
     { name: "chain-of-thought", label: "two asks sharing accumulating context", source: "example" },
     { name: "research-notes", label: "TS control flow orchestrating nola functions", source: "example" },
 ];
-/** The first menu's templates: the builtins and the featured example, in registry order. */
+/** The first menu's templates: the featured examples and `empty`, in registry order. */
 export function featuredNames() {
     return TEMPLATES.filter((t) => t.source === "builtin" || t.featured).map((t) => t.name);
 }

package/dist/scaffold.d.ts

@@ -1,3 +1,4 @@
+import type { Runtime } from "./package-manager.js";
 import { type ProviderId } from "./providers.js";
 export interface ScaffoldResult {
     root: string;
@@ -13,18 +14,22 @@ export interface ScaffoldOptions {
     /**
      * The inference provider chosen in the wizard; default "none" (the
      * template's own config). Any live provider replaces `nola.config.ts` with
-     * that provider's config, skips the offline templates' replay ledger, and renders
-     * the matching README notes.
+     * that provider's config and drops the offline templates' replay ledger.
      */
     provider?: ProviderId;
     /**
      * The editor chosen in the wizard; default "none". Decides the next-steps
-     * comment rendered at the top of the template's src/main.ts: with VS Code
-     * it names F5, breakpoints and the recommended extension (all of which the
-     * .vscode files the flow writes make true); without one it stays
-     * editor-neutral.
+     * comment that opens the template's entry file: with VS Code it names F5,
+     * breakpoints and the recommended extension (all of which the .vscode
+     * files the flow writes make true); without one it stays editor-neutral.
      */
     ide?: "vscode" | "none";
+    /**
+     * The runtime the project runs on; default "node". "bun" adds bunfig.toml with the
+     * @nola-lang/bun preload, a `bun <entry>` start script, the devDependency and
+     * engines.bun — build/check stay the Node CLI (spec 2026-10-14-bun-support).
+     */
+    runtime?: Runtime;
 }
 /** The config a live provider choice writes over the template's own (`templates/_providers/<id>.config.ts`). */
 export declare function providerConfigUrl(provider: Exclude<ProviderId, "none">): URL;
@@ -41,24 +46,39 @@ export declare function vendorEnvVar(template: string, provider: ProviderId): st
  * `.gitignore` keeps trackable (`!.env.example`), so it can be committed.
  */
 export declare function envExample(envVar: string): string;
+/** The Bun project's bunfig.toml: the preload for `bun src/main.tsi` and for `bun test`. */
+export declare const BUNFIG_TOML = "preload = [\"@nola-lang/bun/preload\"]\n\n[test]\npreload = [\"@nola-lang/bun/preload\"]\n";
+/** The Bun floor @nola-lang/bun needs (process.getBuiltinModule). */
+export declare const BUN_ENGINE = ">=1.3.0";
+/** A Bun project's manifest additions on top of the template's: the start script, the devDependency, engines.bun. */
+export declare function applyBunRuntime(content: string, opts: {
+    entry: string;
+    version: string;
+}): string;
 /**
- * Add the recommended `.gitignore` to an example's files. Examples are copied
- * verbatim from `examples/`, where the monorepo's root ignore file covers them,
- * so they carry none — one an example does carry wins.
+ * Add the recommended `.gitignore` to a template's files. Templates are
+ * copied as committed — examples from `examples/`, where the monorepo's root
+ * ignore file covers them — so they carry none; one a template does carry wins.
  */
 export declare function withRecommendedGitignore(files: Map<string, string>): Promise<Map<string, string>>;
 /**
- * The comment that opens the entry file (src/main.ts, or the `.tsi` entry
- * of a one-file template) — the file the scaffold lands the user on (VS Code opens it
- * as the active editor), so it carries the first three things to do. The VS
- * Code variant only ships with the editor step's .vscode files, which are
- * what make F5 and the extension prompt real.
+ * The comment that opens the entry file (the `.tsi` entry of a one-file
+ * template and of `empty`, else the plain-TS src/main.ts) — the file the
+ * scaffold lands the user on (VS Code opens it as the active editor), so it
+ * carries the first three things to do. The VS Code variant only ships with
+ * the editor step's .vscode files, which are what make F5 and the extension
+ * prompt real.
  */
-export declare function nextStepsComment(ide: "vscode" | "none", template: string): string;
+export declare function nextStepsComment(ide: "vscode" | "none", template: string, runtime?: Runtime): string;
 export declare function ownVersion(): Promise<string>;
 /**
  * Lay a template down into `targetDir`. One implementation serves both entry
- * points: the `create-nola-lang` bin (`npm create nola-lang`) and `nola init`.
+ * points — the `create-nola-lang` bin (`npm create nola-lang`) and `nola init`
+ * — and both sources: the files are collected as committed, then the scaffold
+ * adds what a project needs on top — the chosen provider's config (dropping
+ * the replay ledger), the project name and the lockstep ranges in
+ * package.json, the recommended .gitignore, the vendor key's .env.example,
+ * and the next-steps comment at the top of the entry file.
  */
 export declare function scaffold(targetDir: string, opts?: ScaffoldOptions): Promise<ScaffoldResult>;
 //# sourceMappingURL=scaffold.d.ts.map