create-nola-lang 0.1.11 → 0.1.13

package/dist/flow.d.ts

@@ -91,6 +91,16 @@ export declare const EDITOR_QUESTION = "Set up your Editor?";
 export declare const AGENTS_QUESTION = "Set up Coding Agents?";
 /** The grouped list a yes opens. */
 export declare const SETUP_LIST_QUESTION = "What to set up? (Space toggles, Enter confirms)";
+export declare const TEMPLATE_QUESTION = "Select a template:";
+export declare const EXAMPLE_QUESTION = "Select an example:";
+/** the first menu's last row — opens the examples menu */
+export declare const MORE_EXAMPLES = "more-examples";
+/** the examples menu's last row — back to the first menu */
+export declare const BACK = "back";
+/** The first menu: the builtin templates and the featured example in registry order, then the examples row. */
+export declare function templateMenu(): PrompterOption[];
+/** The second menu: the curated examples the first menu does not carry, in registry order, then Back. */
+export declare function exampleMenu(): PrompterOption[];
 export declare const PROVIDER_QUESTION = "Select an inference provider:";
 /** `nola key`'s confirmation before the browser opens (the scaffold's consent is the provider select itself). */
 export declare const SIGN_IN_QUESTION = "This machine already used its 25 free Nola runs. Sign in to get an API key for this project?";
@@ -100,8 +110,8 @@ export declare const SIGN_IN_QUESTION = "This machine already used its 25 free N
  * machine used them, a key on the account when already signed in.
  */
 export declare function nolaHint(path: KeyPath): string;
-/** The provider menu with the nola row worded for this machine. */
-export declare function providerOptions(path: KeyPath): PrompterOption[];
+/** The provider menu with the nola row worded for this machine and the typesafe row for this template. */
+export declare function providerOptions(path: KeyPath, template?: string): PrompterOption[];
 /** Args fill prompts; whatever is missing is asked (never asked non-interactively). */
 export declare function resolveScaffoldOptions(input: FlowInput, prompter: Prompter): Promise<FlowOutcome>;
 /** Non-interactive prompter: output only; being asked anything is a bug. */
@@ -122,7 +132,7 @@ export interface RunFlowArgs {
 export declare const FLOW_OPTIONS: {
     readonly template: {
         readonly type: "string";
-        readonly description: "template to scaffold (starter, empty, or a curated example)";
+        readonly description: "template to scaffold (feature-extraction, function-calling, typescript-interop, empty, or a curated example)";
     };
     readonly add: {
         readonly type: "boolean";
@@ -130,11 +140,11 @@ export declare const FLOW_OPTIONS: {
     };
     readonly ide: {
         readonly type: "string";
-        readonly description: "editor setup: vscode | none";
+        readonly description: "editor setup: vscode (the default) | none";
     };
     readonly agents: {
         readonly type: "string";
-        readonly description: `agent skill files: ${string} | all | none`;
+        readonly description: `agent skill files: ${string} | all | none (default: claude,universal)`;
     };
     readonly provider: {
         readonly type: "string";
@@ -173,6 +183,10 @@ export interface RunFlowOptions {
 }
 /** The last non-empty output line, colour codes stripped, trimmed to one spinner line. */
 export declare function lastOutputLine(output: string): string | undefined;
+/** The last question when VS Code's `code` command is on PATH… */
+export declare const INSTALL_OPEN_QUESTION = "Install dependencies and open VS Code?";
+/** …and when it is not (2026-09-18): the editor is neither promised nor opened. */
+export declare const INSTALL_QUESTION = "Install dependencies?";
 /**
  * A Retry-After wait in words. The per-address daily limit answers with the
  * seconds left in the day ("49832 s" — nobody reads that as fourteen hours),

package/dist/flow.js

@@ -6,7 +6,7 @@ import { addNola } from "./add.js";
 import { AGENT_IDS, AGENT_OPTIONS, defaultAgents, parseAgentsFlag, writeAgentSkills } from "./agents.js";
 import { NolaApiError, nolaApiUrl } from "./api.js";
 import { signIn } from "./auth.js";
-import { LINK_CHECKOUT_ENV, linkCheckoutFromEnv, linkCheckoutPackages } from "./checkout.js";
+import { CHECKOUT_DIST_SKIP_GLOB, LINK_CHECKOUT_ENV, linkCheckoutFromEnv, linkCheckoutPackages, skipCheckoutDistInLaunch, } from "./checkout.js";
 import { defineCommand } from "./cli.js";
 import { readSession } from "./credentials.js";
 import { ExampleFetchError } from "./github.js";
@@ -18,23 +18,32 @@ import { nodeVersionWarning } from "./node-version.js";
 import { openBrowser } from "./open-url.js";
 import { detectPackageManager, packageManagerCommands } from "./package-manager.js";
 import { isProviderId, PROVIDERS, providerById, providerIds } from "./providers.js";
-import { TEMPLATES, templateByName, templateNames } from "./registry.js";
-import { ownVersion, scaffold } from "./scaffold.js";
+import { entryFile, exampleNames, featuredNames, TEMPLATES, templateByName, templateNames } from "./registry.js";
+import { ownVersion, scaffold, vendorEnvVar } from "./scaffold.js";
 import { applyTrial } from "./trial.js";
 const DEFAULT_DIR = "nola-app";
-const DEFAULT_TEMPLATE = "starter";
+const DEFAULT_TEMPLATE = "feature-extraction";
 /*
  * The wizard, in order (spec 2026-08-12-interactive-init-design.md, reordered
  * 2026-09-03, provider select 2026-09-08): name → template → "Select an
  * inference provider" (Nola first — the free runs, or a key on the account —
- * then the vendors, then skip) → "Set up your editor and coding agents?"
- * (yes/no, default yes — the whole no is one Enter) → on yes, ONE grouped
- * checkbox list (editor + coding agents), then — once the files are on
- * disk — "Install dependencies and open VS Code?". Every question is
- * answered before anything is written; the nola key request runs after the
- * last question.
+ * then the vendors, then skip) → then — once the files are on disk —
+ * "Install dependencies and open VS Code?". The editor setup and the agent
+ * skill are written WITHOUT a question (2026-09-18; `--ide none` /
+ * `--agents …` override): the "Set up your Editor and Coding Agents?" gate
+ * and its grouped list are kept behind `SETUP_STEP_ASKED` should the step
+ * come back. Every question is answered before anything is written; the
+ * nola key request runs after the last question.
  */
 export const NAME_QUESTION = `Project name (press Enter to keep "${DEFAULT_DIR}"):`;
+/**
+ * The retired setup step (2026-09-18). false = the editor setup and the agent
+ * skill are defaults (`DEFAULT_IDE`, `defaultAgents`) and nothing is asked;
+ * flip to true to bring the gate + grouped list back exactly as they were.
+ */
+const SETUP_STEP_ASKED = false;
+/** The editor the scaffold sets up unless `--ide none` says otherwise. */
+const DEFAULT_IDE = "vscode";
 /** The yes/no gate in front of the setup list; narrowed when a flag already answered one half. */
 export const SETUP_QUESTION = "Set up your Editor and Coding Agents?";
 export const EDITOR_QUESTION = "Set up your Editor?";
@@ -46,25 +55,69 @@ const EDITOR_OPTIONS = [
     { value: "vscode", label: "VS Code", hint: ".vscode/ with a debug launch config + extension recommendation" },
 ];
 function templateOption(t) {
-    // a pinned template names its vendor in the row itself: `example: triage-ticket (typesafe.ai)`
+    // a pinned template names its vendor in the row itself: `triage-ticket (typesafe.ai)`
     const vendor = t.provider ? ` (${t.provider.label})` : "";
-    return { value: t.name, label: t.source === "example" ? `example: ${t.name}${vendor}` : `${t.name}${vendor}`, hint: t.label };
+    return { value: t.name, label: `${t.name}${vendor}`, hint: t.label };
+}
+/*
+ * 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.
+ */
+export const TEMPLATE_QUESTION = "Select a template:";
+export const EXAMPLE_QUESTION = "Select an example:";
+/** the first menu's last row — opens the examples menu */
+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. */
+export function templateMenu() {
+    const featured = featuredNames().map((name) => templateOption(templateByName(name)));
+    return [...featured, { value: MORE_EXAMPLES, label: "More examples…", hint: exampleNames().join(", ") }];
+}
+/** 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" }];
+}
+/** Ask the two-level template menu until a template is chosen; null = cancelled. */
+async function selectTemplate(prompter) {
+    for (;;) {
+        const choice = await prompter.select(TEMPLATE_QUESTION, templateMenu());
+        if (choice === null)
+            return null;
+        if (choice !== MORE_EXAMPLES)
+            return choice;
+        const example = await prompter.select(EXAMPLE_QUESTION, exampleMenu());
+        if (example === null)
+            return null;
+        if (example !== BACK)
+            return example;
+    }
 }
 /**
- * The setup step: a yes/no gate (default yes), then editor + coding agents in
- * one grouped checkbox list, VS Code and both skill copies preselected — so the
- * defaults are two Enters and the whole no is one. `--ide` / `--agents` each
- * fill their half — a group a flag already answered is not shown and the gate
- * narrows to the half that remains; a no leaves the asked halves at none.
- * null = cancelled. Non-interactive defaults: no editor, no agents.
+ * The editor + agents answer. Today (the step is retired): the flags, else the
+ * defaults — VS Code and both skill targets — interactive or not, so a scaffold
+ * carries `.vscode/` and the skill unless `--ide none` / `--agents none` opt
+ * out. With `SETUP_STEP_ASKED`: a yes/no gate (default yes), then editor +
+ * coding agents in one grouped checkbox list with the same defaults
+ * preselected; `--ide` / `--agents` each fill their half — a group a flag
+ * already answered is not shown and the gate narrows to the half that
+ * remains; a no leaves the asked halves at none. null = cancelled.
  */
 async function resolveSetup(input, prompter, dir) {
     const ide = input.ide === "vscode" || input.ide === "none" ? input.ide : undefined;
     const agents = input.agents !== undefined ? parseAgentsFlag(input.agents) : undefined;
     if (ide !== undefined && agents !== undefined)
         return { ide, agents };
-    if (!input.interactive)
-        return { ide: ide ?? "none", agents: agents ?? [] };
+    if (!input.interactive || !SETUP_STEP_ASKED)
+        return { ide: ide ?? DEFAULT_IDE, agents: agents ?? defaultAgents(dir) };
     const groups = [];
     const initial = [];
     if (ide === undefined) {
@@ -107,9 +160,27 @@ export function nolaHint(path) {
             return providerById("nola")?.hint ?? "";
     }
 }
-/** The provider menu with the nola row worded for this machine. */
-export function providerOptions(path) {
-    return PROVIDERS.map((p) => ({ value: p.id, label: p.label, hint: p.id === "nola" ? nolaHint(path) : p.hint }));
+/**
+ * The typesafe row's bracket: the vendor serves literal unions and booleans
+ * only, so for a template whose asks go further the hint says so by name
+ * (the template was chosen one question earlier); no template (add mode)
+ * gets the generic form; a template whose own config already names
+ * typesafe.ai needs no warning.
+ */
+function typesafeHint(base, template) {
+    if (template === undefined)
+        return `${base} (literal unions and booleans only)`;
+    if (templateByName(template)?.provider?.label === "typesafe.ai")
+        return base;
+    return `${base} (does not support every construct in ${template}: literal unions and booleans only)`;
+}
+/** The provider menu with the nola row worded for this machine and the typesafe row for this template. */
+export function providerOptions(path, template) {
+    return PROVIDERS.map((p) => ({
+        value: p.id,
+        label: p.label,
+        hint: p.id === "nola" ? nolaHint(path) : p.id === "typesafe" ? typesafeHint(p.hint, template) : p.hint,
+    }));
 }
 /** The provider a flag already chose: `--provider`, else the `--trial` / `--no-trial` shorthands; throws when they disagree. */
 function flaggedProvider(input) {
@@ -135,17 +206,18 @@ function flaggedProvider(input) {
  * one Enter away, Ctrl+C cancels). The key itself is minted later, on the
  * stored session, after every question — nothing is consumed by a cancel.
  */
-async function resolveProvider(input, prompter, pinned = false) {
+async function resolveProvider(input, prompter, template) {
     const flagged = flaggedProvider(input);
     if (flagged !== undefined)
         return flagged;
     // A template whose own config names its vendor (triage-ticket → typesafe())
     // is not asked: "none" keeps that config, and the outro names its env var.
+    const pinned = template !== undefined && templateByName(template)?.provider !== undefined;
     if (pinned || !input.interactive)
         return "none";
     const path = input.keyPath ?? { kind: "trial" };
     while (true) {
-        const choice = await prompter.select(PROVIDER_QUESTION, providerOptions(path));
+        const choice = await prompter.select(PROVIDER_QUESTION, providerOptions(path, template));
         if (choice === null)
             return null;
         if (!isProviderId(choice))
@@ -156,8 +228,8 @@ async function resolveProvider(input, prompter, pinned = false) {
     }
 }
 /** The provider and setup (editor + agents) questions, in that order, shared by every outcome site; null = cancelled. */
-async function resolveExtras(input, prompter, dir, pinnedProvider = false) {
-    const provider = await resolveProvider(input, prompter, pinnedProvider);
+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);
@@ -261,13 +333,13 @@ export async function resolveScaffoldOptions(input, prompter) {
             template = DEFAULT_TEMPLATE;
         }
         else {
-            const choice = await prompter.select("Select a template:", TEMPLATES.map(templateOption));
+            const choice = await selectTemplate(prompter);
             if (choice === null)
                 return { kind: "cancelled" };
             template = choice;
         }
     }
-    const extras = await resolveExtras(input, prompter, dir, templateByName(template)?.provider !== undefined);
+    const extras = await resolveExtras(input, prompter, dir, template);
     if (extras === null)
         return { kind: "cancelled" };
     return { kind: "scaffold", dir, template, force, ...extras };
@@ -296,10 +368,16 @@ export function plainPrompter() {
  * `nola init`): parseArgs descriptors plus the help line each shows.
  */
 export const FLOW_OPTIONS = {
-    template: { type: "string", description: "template to scaffold (starter, empty, or a curated example)" },
+    template: {
+        type: "string",
+        description: "template to scaffold (feature-extraction, function-calling, typescript-interop, empty, or a curated example)",
+    },
     add: { type: "boolean", description: "add Nola to the existing project in [dir] instead of scaffolding" },
-    ide: { type: "string", description: "editor setup: vscode | none" },
-    agents: { type: "string", description: `agent skill files: ${AGENT_IDS.join(",")} | all | none` },
+    ide: { type: "string", description: "editor setup: vscode (the default) | none" },
+    agents: {
+        type: "string",
+        description: `agent skill files: ${AGENT_IDS.join(",")} | all | none (default: claude,universal)`,
+    },
     provider: {
         type: "string",
         description: `inference provider: ${providerIds().join(" | ")} (nola = 25 free runs; non-interactive default: none)`,
@@ -325,8 +403,7 @@ function commented(command, note) {
 function nextSteps(outcome, fileCount, name, pm, installed = false, grant = null) {
     const cmd = packageManagerCommands(pm);
     // a chosen vendor's env var, else the one the template's own config reads (a pinned template under "none")
-    const vendorEnv = providerById(outcome.provider)?.envVar ??
-        (outcome.provider === "none" ? templateByName(outcome.template)?.provider?.envVar : undefined);
+    const vendorEnv = vendorEnvVar(outcome.template, outcome.provider);
     const startNote = grant
         ? grant.source === "trial"
             ? "25 free Nola runs — key in .env"
@@ -346,8 +423,6 @@ function nextSteps(outcome, fileCount, name, pm, installed = false, grant = null
 }
 /** How many trailing lines of a failed install's output the note shows. */
 const INSTALL_LOG_TAIL = 20;
-/** Every template's entry (builtin and curated examples alike) — what launch.json runs and VS Code opens. */
-const ENTRY_FILE = "src/main.ts";
 /** The last non-empty output line, colour codes stripped, trimmed to one spinner line. */
 export function lastOutputLine(output) {
     const lines = stripVTControlCharacters(output).split(/\r?\n/);
@@ -358,18 +433,24 @@ export function lastOutputLine(output) {
     }
     return undefined;
 }
+/** The last question when VS Code's `code` command is on PATH… */
+export const INSTALL_OPEN_QUESTION = "Install dependencies and open VS Code?";
+/** …and when it is not (2026-09-18): the editor is neither promised nor opened. */
+export const INSTALL_QUESTION = "Install dependencies?";
 /**
- * The optional last step: "Install dependencies and open VS Code?". Offered
- * only when the scaffold is interactive AND an editor was chosen — the editor
- * step is what makes opening it meaningful. A yes runs the package manager's
- * install under a spinner (its output is captured, the latest line shown
- * beneath the title, the tail printed only on failure) and then opens the
- * project in VS Code; Ctrl+C here is a plain no (the project is already on
- * disk). Returns whether the install succeeded so the outro can drop that
- * line.
+ * The optional last step: "Install dependencies and open VS Code?" — or just
+ * "Install dependencies?" on a machine without VS Code's `code` command,
+ * which then opens nothing. Offered only when the scaffold is interactive AND
+ * an editor was chosen — the editor step is what makes opening it meaningful.
+ * A yes runs the package manager's install under a spinner (its output is
+ * captured, the latest line shown beneath the title, the tail printed only on
+ * failure) and then opens the project in VS Code; Ctrl+C here is a plain no
+ * (the project is already on disk). Returns whether the install succeeded so
+ * the outro can drop that line.
  */
-async function offerInstallAndOpen(dir, pm, prompter, launcher, linkCheckout) {
-    const yes = await prompter.confirm("Install dependencies and open VS Code?", true);
+async function offerInstallAndOpen(dir, entryPath, pm, prompter, launcher, linkCheckout) {
+    const vscode = launcher.hasVscode();
+    const yes = await prompter.confirm(vscode ? INSTALL_OPEN_QUESTION : INSTALL_QUESTION, true);
     if (!yes)
         return { installed: false };
     const cmd = packageManagerCommands(pm);
@@ -390,8 +471,12 @@ async function offerInstallAndOpen(dir, pm, prompter, launcher, linkCheckout) {
         // at that workspace build instead.
         if (linkCheckout !== null) {
             const linked = await linkCheckoutPackages(dir, linkCheckout);
+            // The linked runtime now lives outside node_modules, so the launch
+            // config must blackbox it too or F10 over the first ask runs to the end.
+            const skipped = await skipCheckoutDistInLaunch(dir);
             prompter.note(`${LINK_CHECKOUT_ENV}: linked ${linked.join(", ")} to ${join(linkCheckout, "packages")} — ` +
-                `a later ${cmd.install} restores the registry copies.`);
+                `a later ${cmd.install} restores the registry copies.` +
+                (skipped ? `\nAdded "${CHECKOUT_DIST_SKIP_GLOB}" to skipFiles in .vscode/launch.json so stepping stays in your code.` : ""));
         }
     }
     else {
@@ -399,11 +484,14 @@ async function offerInstallAndOpen(dir, pm, prompter, launcher, linkCheckout) {
         const tail = stripVTControlCharacters(output).trim().split(/\r?\n/).slice(-INSTALL_LOG_TAIL).join("\n");
         prompter.note(`${tail ? `${tail}\n` : ""}Run ${cmd.install} yourself once the cause is fixed.`);
     }
+    if (!vscode)
+        return { installed };
     // Land on the entry file, not an empty window: it opens with the next
     // steps (F5, breakpoints, the extension) as its first lines.
-    const entry = existsSync(join(dir, ENTRY_FILE)) ? ENTRY_FILE : undefined;
+    const entry = existsSync(join(dir, entryPath)) ? entryPath : undefined;
     const opened = await launcher.openVscode(dir, entry);
     if (opened === "not-found") {
+        // `code` was on PATH a moment ago and is gone now — rare, but say so.
         prompter.note("VS Code's `code` command is not on PATH, so the folder was not opened. " +
             "In VS Code run \"Shell Command: Install 'code' command in PATH\" (macOS) or re-run the installer with \"Add to PATH\" (Windows), then open the folder from VS Code.");
     }
@@ -563,7 +651,7 @@ export async function runFlow(args, opts = {}) {
             }
             let ideWrote = [];
             if (outcome.ide === "vscode") {
-                const ide = await writeVscodeSetup(outcome.dir);
+                const ide = await writeVscodeSetup(outcome.dir, entryFile(outcome.template));
                 ideWrote = ide.wrote;
                 for (const note of ide.skipped)
                     prompter.note(note);
@@ -576,7 +664,7 @@ export async function runFlow(args, opts = {}) {
                     prompter.note(note);
             }
             const launch = interactive && outcome.ide !== "none"
-                ? await offerInstallAndOpen(outcome.dir, pm, prompter, opts.launcher ?? realLauncher, opts.linkCheckout ?? linkCheckoutFromEnv())
+                ? await offerInstallAndOpen(outcome.dir, entryFile(outcome.template), pm, prompter, opts.launcher ?? realLauncher, opts.linkCheckout ?? linkCheckoutFromEnv())
                 : { installed: false };
             const message = nextSteps({ ...outcome, provider }, files.length + trialWrote.length + ideWrote.length + agWrote.length, basename(resolve(outcome.dir)), pm, launch.installed, grant);
             if (prompter.outro)
@@ -587,7 +675,7 @@ export async function runFlow(args, opts = {}) {
         }
         catch (err) {
             if (err instanceof ExampleFetchError && interactive) {
-                prompter.note(`${err.message}\nThe "starter" and "empty" templates work offline.`);
+                prompter.note(`${err.message}\nThe builtin templates (${builtinNames()}) work offline.`);
                 input.dir = outcome.dir; // keep the chosen dir, re-pick the template
                 input.template = undefined;
                 continue;

package/dist/ide.d.ts

@@ -4,6 +4,6 @@ export interface IdeSetupResult {
     /** human-readable notes about files left untouched */
     skipped: string[];
 }
-/** Write .vscode/launch.json + extensions.json; never rewrites an existing file. */
-export declare function writeVscodeSetup(targetDir: string): Promise<IdeSetupResult>;
+/** Write .vscode/launch.json (running `entry`) + extensions.json; never rewrites an existing file. */
+export declare function writeVscodeSetup(targetDir: string, entry?: string): Promise<IdeSetupResult>;
 //# sourceMappingURL=ide.d.ts.map

package/dist/ide.js

@@ -1,25 +1,26 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { DEFAULT_ENTRY } from "./registry.js";
 /**
  * The resolved form of the VS Code extension's own "Nola: Launch File"
- * configuration snippet, pointed at the templates' real entry (src/main.ts —
+ * configuration snippet, pointed at the template's real entry (src/main.ts —
  * plain .ts runs under modern Node's native type stripping; the loader
- * handles .tsi). resolveSourceMapLocations and skipFiles are the two
+ * handles .tsi — or a one-file template's src/main.tsi, which the loader runs as
+ * the entry module). resolveSourceMapLocations and skipFiles are the two
  * launch-config invariants AGENTS.md documents as mandatory for .tsi
  * debugging — keep them.
  */
-const LAUNCH_JSON = {
+const launchJson = (entry) => ({
     version: "0.2.0",
     configurations: [
         {
             type: "node",
             request: "launch",
             name: "Nola: Launch main",
-            // ${workspaceFolder} below is VS Code's own launch-config variable —
-            // deliberately a literal string, never a JS template.
-            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable syntax
-            program: "${workspaceFolder}/src/main.ts",
+            // ${workspaceFolder} is VS Code's own launch-config variable — it must
+            // reach the file verbatim, hence the escaped dollar.
+            program: `\${workspaceFolder}/${entry}`,
             runtimeArgs: ["--import", "nola-lang/register", "--enable-source-maps"],
             console: "integratedTerminal",
             // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable syntax
@@ -29,17 +30,17 @@ const LAUNCH_JSON = {
             skipFiles: ["<node_internals>/**", "**/node_modules/**"],
         },
     ],
-};
+});
 /** publisher.name of packages/vscode — resolves once the extension is on the marketplace. */
 const EXTENSIONS_JSON = { recommendations: ["nola.nola-vscode"] };
-/** Write .vscode/launch.json + extensions.json; never rewrites an existing file. */
-export async function writeVscodeSetup(targetDir) {
+/** Write .vscode/launch.json (running `entry`) + extensions.json; never rewrites an existing file. */
+export async function writeVscodeSetup(targetDir, entry = DEFAULT_ENTRY) {
     const vscodeDir = join(resolve(targetDir), ".vscode");
     await mkdir(vscodeDir, { recursive: true });
     const wrote = [];
     const skipped = [];
     const files = [
-        ["launch.json", LAUNCH_JSON],
+        ["launch.json", launchJson(entry)],
         ["extensions.json", EXTENSIONS_JSON],
     ];
     for (const [name, content] of files) {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export type { Session } from "./credentials.js";
 export { CREDENTIALS_FILE, credentialsPath, deleteSession, readSession, writeSession } from "./credentials.js";
 export { collectExampleFromDisk, devExamplesDir, rewriteExamplePackageJson } from "./examples.js";
 export type { FlowInput, FlowOutcome, KeyPath, Prompter, PrompterOption, RunFlowArgs, RunFlowOptions } from "./flow.js";
-export { CREATE_COMMAND, FLOW_OPTIONS, nolaHint, PROVIDER_QUESTION, plainPrompter, providerOptions, resolveScaffoldOptions, runFlow, SIGN_IN_QUESTION } from "./flow.js";
+export { CREATE_COMMAND, FLOW_OPTIONS, INSTALL_OPEN_QUESTION, INSTALL_QUESTION, nolaHint, PROVIDER_QUESTION, plainPrompter, providerOptions, resolveScaffoldOptions, runFlow, SIGN_IN_QUESTION, } from "./flow.js";
 export type { FetchLike } from "./github.js";
 export { ExampleFetchError, fetchExampleFromGitHub } from "./github.js";
 export type { NolaHomeConfig, TrialAccountRecord } from "./home-config.js";

package/dist/index.js

@@ -10,6 +10,8 @@ import {
   ExampleFetchError,
   FLOW_OPTIONS,
   HOME_CONFIG_FILE,
+  INSTALL_OPEN_QUESTION,
+  INSTALL_QUESTION,
   NolaApiError,
   PROVIDERS,
   PROVIDER_QUESTION,
@@ -85,7 +87,7 @@ import {
   writeEnvKey,
   writeSession,
   writeVscodeSetup
-} from "./chunk-MAULRZZD.js";
+} from "./chunk-LUSVIOAN.js";
 import {
   clackPrompter
 } from "./chunk-7IQIRMK6.js";
@@ -144,6 +146,8 @@ export {
   ExampleFetchError,
   FLOW_OPTIONS,
   HOME_CONFIG_FILE,
+  INSTALL_OPEN_QUESTION,
+  INSTALL_QUESTION,
   NolaApiError,
   PROVIDERS,
   PROVIDER_QUESTION,

package/dist/launch.d.ts

@@ -5,6 +5,8 @@ import type { PackageManager } from "./package-manager.js";
  * calls; tests inject a recorder, the CLI uses `realLauncher`.
  */
 export interface Launcher {
+    /** Is VS Code's `code` command on PATH? Checked BEFORE the question, so a machine without VS Code is never offered it. */
+    hasVscode(): boolean;
     /**
      * `<pm> install` in the project dir. Its output (stdout + stderr, as it
      * arrives) goes to `onOutput` instead of the terminal, so the flow can keep

package/dist/launch.js

@@ -65,6 +65,7 @@ export function installArgs(pm) {
     return pm === "npm" ? ["install", "--no-audit", "--no-fund"] : ["install"];
 }
 export const realLauncher = {
+    hasVscode: () => findOnPath("code") !== undefined,
     install: (pm, dir, onOutput) => run(pm, installArgs(pm), dir, onOutput),
     async openVscode(dir, entry) {
         const code = findOnPath("code");

package/dist/main.js

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

package/dist/providers.d.ts

@@ -1,11 +1,14 @@
 /**
  * The inference-provider menu the wizard shows right after the template
  * (2026-09-08, replacing the yes/no trial question). Static, like the
- * template registry: `nola` is the platform (the free trial, or a key on the
- * account — see `keyPath`), the three vendors write a bring-your-own config,
- * `none` is the offline default (the starter replays its ledger).
+ * 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
+ * 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.
  */
-export type ProviderId = "nola" | "openai" | "anthropic" | "google" | "none";
+export type ProviderId = "nola" | "openai" | "anthropic" | "google" | "typesafe" | "none";
 export interface ProviderDef {
     id: ProviderId;
     /** menu label */

package/dist/providers.js

@@ -1,5 +1,5 @@
 export const PROVIDERS = [
-    { id: "nola", label: "Nola", hint: "25 free runs, no account or provider key needed", model: '"nola"' },
+    { id: "nola", label: "nola: dev", hint: "25 free hosted runs, no API key required, suited for dev experiments", model: '"nola"' },
     { id: "openai", label: "OpenAI", hint: 'openai("gpt-5-mini"), reads OPENAI_API_KEY', envVar: "OPENAI_API_KEY", model: 'openai("gpt-5-mini")' },
     {
         id: "anthropic",
@@ -9,7 +9,8 @@ export const PROVIDERS = [
         model: 'anthropic("claude-sonnet-4-5")',
     },
     { 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: "none", label: "Skip for now", hint: "the starter runs offline from its replay ledger; pick a model in nola.config.ts later" },
+    { 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" },
 ];
 export function providerById(id) {
     return PROVIDERS.find((p) => p.id === id);

package/dist/registry.d.ts

@@ -1,14 +1,34 @@
 /**
  * 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.
- * extract-person is deliberately absent — the starter IS extract-person plus
- * the replay ledger.
+ *
+ * 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 —
+ * `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.
  */
 export interface TemplateDef {
     name: string;
     /** one-line menu description */
     label: string;
     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).
+     */
+    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.
+     */
+    entry?: string;
     /**
      * The vendor the template's OWN config names. The flow skips the provider
      * question for such a template (its config is the point of the example),
@@ -20,7 +40,15 @@ export interface TemplateDef {
         envVar: string;
     };
 }
+/** 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. */
+export declare function featuredNames(): string[];
+/** The examples behind "More examples…": every example the first menu does not carry. */
+export declare function exampleNames(): string[];
 export declare function templateByName(name: string): TemplateDef | undefined;
 export declare function templateNames(): string[];
+/** The template's entry file — what `start` runs, launch.json runs and VS Code opens. */
+export declare function entryFile(template: string | undefined): string;
 //# sourceMappingURL=registry.d.ts.map