create-nola-lang 0.1.11 → 0.1.13

package/dist/registry.js

@@ -1,5 +1,26 @@
+/** 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: "starter", label: "typed extraction, runs offline out of the box", source: "builtin" },
+    { name: "feature-extraction", label: "extract typed data from context", source: "builtin", entry: "src/main.tsi" },
+    {
+        name: "function-calling",
+        label: "call an async function from a TypeScript file",
+        source: "builtin",
+        entry: "src/main.tsi",
+    },
+    {
+        name: "typescript-interop",
+        label: "an infer function example, imported and awaited from plain TypeScript",
+        source: "builtin",
+    },
+    {
+        name: "triage-ticket",
+        label: "ticket triage on a non-chat model: literal unions and booleans as typed questions",
+        source: "example",
+        featured: true,
+        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: "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" },
@@ -7,17 +28,23 @@ export const TEMPLATES = [
     { name: "classify-message", label: "closed label sets: union alias, string enum, inline union", source: "example" },
     { name: "chain-of-thought", label: "two asks sharing accumulating context", source: "example" },
     { name: "research-notes", label: "TS control flow orchestrating nola functions", source: "example" },
-    {
-        name: "triage-ticket",
-        label: "ticket triage: literal unions and booleans as typed questions",
-        source: "example",
-        provider: { label: "typesafe.ai", envVar: "TYPESAFE_API_KEY" },
-    },
 ];
+/** The first menu's templates: the builtins and the featured example, in registry order. */
+export function featuredNames() {
+    return TEMPLATES.filter((t) => t.source === "builtin" || t.featured).map((t) => t.name);
+}
+/** The examples behind "More examples…": every example the first menu does not carry. */
+export function exampleNames() {
+    return TEMPLATES.filter((t) => t.source === "example" && !t.featured).map((t) => t.name);
+}
 export function templateByName(name) {
     return TEMPLATES.find((t) => t.name === name);
 }
 export function templateNames() {
     return TEMPLATES.map((t) => t.name);
 }
+/** The template's entry file — what `start` runs, launch.json runs and VS Code opens. */
+export function entryFile(template) {
+    return (template === undefined ? undefined : templateByName(template)?.entry) ?? DEFAULT_ENTRY;
+}
 //# sourceMappingURL=registry.js.map

package/dist/scaffold.d.ts

@@ -6,14 +6,14 @@ export interface ScaffoldResult {
 }
 export interface ScaffoldOptions {
     name?: string;
-    /** template name; default "starter" */
+    /** template name; default "feature-extraction" */
     template?: string;
     /** remove existing files in a non-empty target first (set only after an interactive confirm) */
     force?: boolean;
     /**
      * 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 starter's replay ledger, and renders
+     * that provider's config, skips the offline templates' replay ledger, and renders
      * the matching README notes.
      */
     provider?: ProviderId;
@@ -28,6 +28,19 @@ export interface ScaffoldOptions {
 }
 /** 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;
+/**
+ * The env var a scaffold's config reads: the chosen vendor's, else — under
+ * "none" — the one the template's own config names (a pinned template such
+ * as triage-ticket). Undefined for nola (the trial key lands in `.env`
+ * itself) and for an offline scaffold.
+ */
+export declare function vendorEnvVar(template: string, provider: ProviderId): string | undefined;
+/**
+ * The `.env.example` a vendor scaffold gets: the key's slot, to copy to
+ * `.env` and fill in. `.env.example` is the one env file the recommended
+ * `.gitignore` keeps trackable (`!.env.example`), so it can be committed.
+ */
+export declare function envExample(envVar: 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,
@@ -35,10 +48,11 @@ export declare function providerConfigUrl(provider: Exclude<ProviderId, "none">)
  */
 export declare function withRecommendedGitignore(files: Map<string, string>): Promise<Map<string, string>>;
 /**
- * The comment that opens 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.
+ * 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.
  */
 export declare function nextStepsComment(ide: "vscode" | "none", template: string): string;
 export declare function ownVersion(): Promise<string>;

package/dist/scaffold.js

@@ -11,6 +11,23 @@ const TEMPLATES_DIR = fileURLToPath(new URL("../templates/", import.meta.url));
 export function providerConfigUrl(provider) {
     return new URL(`../templates/_providers/${provider}.config.ts`, import.meta.url);
 }
+/**
+ * The env var a scaffold's config reads: the chosen vendor's, else — under
+ * "none" — the one the template's own config names (a pinned template such
+ * as triage-ticket). Undefined for nola (the trial key lands in `.env`
+ * itself) and for an offline scaffold.
+ */
+export function vendorEnvVar(template, provider) {
+    return providerById(provider)?.envVar ?? (provider === "none" ? templateByName(template)?.provider?.envVar : undefined);
+}
+/**
+ * The `.env.example` a vendor scaffold gets: the key's slot, to copy to
+ * `.env` and fill in. `.env.example` is the one env file the recommended
+ * `.gitignore` keeps trackable (`!.env.example`), so it can be committed.
+ */
+export function envExample(envVar) {
+    return `# Copy to .env and fill in — \`nola run\` applies .env before evaluating nola.config.ts.\n${envVar}=\n`;
+}
 /** _gitignore ships underscored (npm pack strips nested .gitignore files). */
 const RENAMES = { _gitignore: ".gitignore" };
 /** The ONE recommended .gitignore — every scaffold gets it; no template keeps a copy of its own. */
@@ -26,20 +43,25 @@ export async function withRecommendedGitignore(files) {
     return files;
 }
 /** Files whose __NAME__/__VERSION__, README-note and __NEXT_STEPS__ placeholders are substituted. */
-const SUBSTITUTED = new Set(["package.json", "README.md", "main.ts"]);
+const SUBSTITUTED = new Set(["package.json", "README.md", "main.ts", "main.tsi"]);
 /**
- * The comment that opens 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.
+ * 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.
  */
 export function nextStepsComment(ide, template) {
     if (ide === "vscode") {
-        const breakpointIn = template === "starter" ? "src/person.tsi" : "your .tsi file";
+        const breakpointIn = templateByName(template)?.entry
+            ? "on the `ask` line below"
+            : template === "typescript-interop"
+                ? "in src/person.tsi"
+                : "in your .tsi file";
         return [
             "// Next steps in VS Code:",
             "//   1. Press F5 to run this file (.vscode/launch.json is already set up).",
-            `//   2. Set a breakpoint in ${breakpointIn} and press F5 again to step through the ask.`,
+            `//   2. Set a breakpoint ${breakpointIn} and press F5 again to step through the ask.`,
             '//   3. Install the recommended "Nola" extension when VS Code offers it — IntelliSense,',
             "//      go to definition and diagnostics inside .tsi files.",
         ].join("\n");
@@ -50,14 +72,14 @@ export function nextStepsComment(ide, template) {
         "//   2. Set up your editor (VS Code extension, debugging): https://nola.sh/docs/start/editor-setup/",
     ].join("\n");
 }
-/** Starter files that only make sense for the offline (replay) configuration. */
+/** Template files that only make sense for the offline (replay) configuration. */
 const OFFLINE_ONLY = new Set(["nola.replay.jsonl"]);
 const README_NOTES = {
     offline: {
         START_NOTE: "works offline, no API key needed",
-        PROVIDER_NOTE: "The starter runs offline: `nola.config.ts` replays answers from the committed\n" +
+        PROVIDER_NOTE: "This project runs offline: `nola.config.ts` replays answers from the committed\n" +
             "`nola.replay.jsonl` ledger. The ledger is keyed by the exact prompt, so once\n" +
-            "you edit `src/person.tsi` or add your own asks, switch the config to a real\n" +
+            "you edit the `.tsi` file or add your own asks, switch the config to a real\n" +
             "model (see the comment in `nola.config.ts`): `model: \"nola\"` with a key from\n" +
             "`npx nola-lang key` (25 free runs), or your own provider and its key.",
     },
@@ -81,8 +103,8 @@ function readmeNotes(provider) {
     return {
         START_NOTE: `set ${def.envVar} in .env first`,
         PROVIDER_NOTE: `\`nola.config.ts\` sets \`model: ${def.model}\` — ${def.label} serves inference with the key it reads\n` +
-            `from \`${def.envVar}\`. Put \`${def.envVar}=…\` in \`.env\` (git-ignored; \`nola run\` applies it) before the\n` +
-            "first `npm start`, or switch models in `nola.config.ts`.",
+            `from \`${def.envVar}\`. Copy \`.env.example\` to \`.env\` (git-ignored; \`nola run\` applies it) and fill in\n` +
+            `\`${def.envVar}\` before the first \`npm start\`, or switch models in \`nola.config.ts\`.`,
     };
 }
 export async function ownVersion() {
@@ -108,19 +130,22 @@ async function prepareTarget(absRoot, force) {
 export async function scaffold(targetDir, opts = {}) {
     const root = targetDir;
     const absRoot = resolve(targetDir);
-    const template = opts.template ?? "starter";
+    const template = opts.template ?? "feature-extraction";
     const def = templateByName(template);
     if (!def)
         throw new Error(`unknown template "${template}" (valid: ${templateNames().join(", ")})`);
     await prepareTarget(absRoot, opts.force ?? false);
     const name = opts.name ?? basename(absRoot);
     const version = await ownVersion();
+    const envVar = vendorEnvVar(template, opts.provider ?? "none");
     if (def.source === "example") {
         const dev = await devExamplesDir();
         const exampleFiles = await withRecommendedGitignore(dev ? await collectExampleFromDisk(dev, template) : await fetchExampleFromGitHub(template, version));
         const manifest = exampleFiles.get("package.json");
         if (manifest)
             exampleFiles.set("package.json", rewriteExamplePackageJson(manifest, { name, version }));
+        if (envVar !== undefined && !exampleFiles.has(".env.example"))
+            exampleFiles.set(".env.example", envExample(envVar));
         for (const [relPath, content] of exampleFiles) {
             const target = join(absRoot, relPath);
             await mkdir(join(target, ".."), { recursive: true });
@@ -168,6 +193,10 @@ export async function scaffold(targetDir, opts = {}) {
         await writeFile(join(absRoot, ".gitignore"), await readFile(GITIGNORE_URL, "utf8"));
         files.push(".gitignore");
     }
+    if (envVar !== undefined) {
+        await writeFile(join(absRoot, ".env.example"), envExample(envVar));
+        files.push(".env.example");
+    }
     return { root, files: files.sort() };
 }
 //# sourceMappingURL=scaffold.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nola-lang",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Scaffold a new Nola project (npm create nola, or npm create nola-lang)",
   "keywords": [
     "nola",

package/skills/nola/SKILL.md

@@ -22,7 +22,7 @@ import type { Person } from "./types.js";
 // thenable Intent<T>. `await`ing it (or `ask`) runs the inference.
 infer function extractPerson(.text: string) {
   // `ask` resolves an intent the way `await` resolves a promise.
-  const person = ask ..`Extract the person described in the text`<Person>;
+  const person = ask `Extract the person described in the text`<Person>;
   return person;
 }
 ```
@@ -33,10 +33,13 @@ infer function extractPerson(.text: string) {
 - `.name: T` parameters are CONTEXT parameters: their values are shown to
   the LLM. Plain (no dot) parameters are ordinary values the LLM never
   sees. `.` is only legal on infer-function parameters. Rule of thumb:
-  ONE dot in (`.name` — the value flows into the model), TWO dots out
-  (`` ..`prompt` `` — a value comes out of it).
-- `` ask ..`prompt`<T> `` — an extractor: asks the LLM for a `T`.
-  `${...}` interpolation works inside the backticks.
+  one dot marks a value flowing INTO the model (`.name`); a template after
+  `ask` is a value coming OUT.
+- `` ask `prompt`<T> `` — an extractor: asks the LLM for a `T`.
+  `${...}` interpolation works inside the backticks. Anywhere that is NOT
+  directly after `ask` — a stored intent, a call-intent argument, an
+  object/array literal — spell it `` ..`prompt`<T> `` (a typed template
+  there without the dots is NOLA2014); `` ask ..`prompt` `` is still legal.
 - `` ask fn`hint`(...) `` — or a plain call whose arguments contain an
   extractor — is a call intent (the LLM fills the extractor-shaped
   arguments, then the function runs). Only `` fn`hint`(...) `` carries

package/skills/nola/references/config.md

@@ -42,11 +42,18 @@ export default defineConfig({
 `apiKeyEnv` (default `"OPENAI_API_KEY"`), `baseUrl` and `fetch`.
 
 `typesafe()` (typesafe.ai's Jev, reads `TYPESAFE_API_KEY`, model defaults to
-`jev-latest`) is NOT a chat model: it serves only asks whose output type is a
-string or number literal union, a boolean, or a flat object of those, and
-fails definitively before the network on anything else. Use it behind
-`fallback([typesafe(), openai({ model: "gpt-5-mini" })])` so other asks
-escalate to a general model. Never scaffold it as the only model.
+`jev-latest`) is NOT a chat model: it is the DECISION model that answers the
+intrinsic `Choice<{…}>` / `Scale<[…]>` / `Prob` types (see syntax.md) beside
+the plain forms — a string or number literal union, a boolean, or a flat object
+of those — and fails definitively before the network on anything else. The
+contextual values (`.params`, `const .x`) travel as its JSON state and each
+property's JSDoc is that question's instructions. An ask whose type contains a
+`Choice` / `Scale` / `Prob` on a chat model is NOLA3018 before the network, so
+route those by name (`model: { default: openai(…), decision: typesafe() }` +
+`ask with decision`), or use `fallback([typesafe(), openai({ model:
+"gpt-5-mini" })])` so plain asks escalate. `threshold` (default 0.5, or
+`.withParams({ providerOptions: { threshold } })` per ask) is the plain-boolean
+cut-off: `true` strictly above it. Never scaffold it as the only model.
 
 `nola` is a NAMESPACE, not a function (`nola({})` is a type error).
 The platform model is written as the STRING `"nola"` — the Nola platform
@@ -78,9 +85,11 @@ is implied — traces go to a Nola console only when `telemetry` lists its
 URL (or `nola.tracer()`).
 
 `npm create nola` asks *Select an inference provider:* right after the
-template — Nola (25 free runs) first, then OpenAI / Anthropic / Gemini, then
-skip — and for Nola writes this config plus the key into `.env` (a vendor gets
-its own config, key left to the user); in an existing project `npx nola-lang
+template — `nola: dev` (25 free hosted runs, no API key, suited for dev experiments) first, then OpenAI / Anthropic / Gemini /
+typesafe.ai (its row brackets the caveat: literal unions and booleans only), then
+skip — and for `nola: dev` writes this config plus the key into `.env` (a vendor gets
+its own config and a `.env.example` with the key's empty slot, e.g. `OPENAI_API_KEY=`,
+to copy to `.env`; the key itself is left to the user); in an existing project `npx nola-lang
 key` mints one (and `npx nola-lang init --add --provider nola` does that plus
 the config and deps).
 A machine gets one anonymous trial; later projects sign in
@@ -115,8 +124,8 @@ export default defineConfig({
 
 ```tsi
 export infer function summarize(.text: string) {
-  const draft = ask with fast ..`a rough summary`<string>;
-  return ask with careful ..`a polished summary of: ${draft}`<string>;
+  const draft = ask with fast `a rough summary`<string>;
+  return ask with careful `a polished summary of: ${draft}`<string>;
 }
 ```
 
@@ -223,11 +232,11 @@ the providers package:
     "check": "nola check"
   },
   "dependencies": {
-    "@nola-lang/providers": "^0.1.11",
-    "@nola-lang/runtime": "^0.1.11"
+    "@nola-lang/providers": "^0.1.13",
+    "@nola-lang/runtime": "^0.1.13"
   },
   "devDependencies": {
-    "nola-lang": "^0.1.11",
+    "nola-lang": "^0.1.13",
     "typescript": "^5.6.0"
   },
   "engines": { "node": ">=22.18" }

package/skills/nola/references/patterns.md

@@ -1,10 +1,85 @@
 # Nola patterns — worked examples
 
-## The starter project, end to end
+## The feature-extraction project: one .tsi file is the program
 
-This is the shape every Nola project takes: `.tsi` files hold the infer
+The smallest Nola program is a single `.tsi` file run directly — `ask` is
+legal at the top level, a bare template literal as the FIRST statement is
+the instruction for the whole file, and `const .x` bindings are context the
+model sees at every ask that follows them (`npm create nola` scaffolds this
+shape as `feature-extraction`):
+
+```tsi
+// src/main.tsi — run with: nola run src/main.tsi
+`You read short professional bios. Answer from the text alone; never invent facts.`
+
+interface Person {
+  name: string;
+  age: number;
+  employer: string;
+  job: string;
+}
+
+const .message = "Alice Smith, 32, is a staff engineer at Acme Corp working on distributed systems.";
+
+const person = ask `the person described in the text`<Person>;
+
+// declared after the first ask, so only the second ask sees it — one answer feeds the next
+const .role = person.job;
+const seniority = ask `the seniority level the role implies`<"junior" | "mid" | "senior" | "staff">;
+
+console.log(JSON.stringify({ ...person, seniority }));
+```
+
+Rules that matter here: the instruction literal must be the very first
+statement (a comment before it is fine, an `import` or a type is not); a
+`.` binding is visible to the asks declared after it in the same or an
+enclosing block, never to its own initializer; `ask` at the top level is
+legal in the module body and top-level blocks/loops, not inside a plain
+function or callback (NOLA2001). When a script outgrows one file, move the
+asks into an `infer function` and call it from plain TypeScript — the shape
+below.
+
+## The function-calling project: a top-level call intent
+
+The same one-file shape, with the other feature (`npm create nola` scaffolds
+it as `function-calling`): the top-level `ask` is a CALL INTENT — the model
+fills the extractor-shaped arguments of an ordinary async function that lives
+in a plain `.ts` file next door, and the call runs with them.
+
+```ts
+// src/tickets.ts — plain TypeScript, nothing Nola about it
+export interface Ticket { id: string; title: string; priority: number }
+const tickets: Ticket[] = [];
+export async function createTicket(title: string, priority: number): Promise<Ticket> {
+  const ticket = { id: `T-${tickets.length + 1}`, title, priority };
+  tickets.push(ticket);
+  return ticket;
+}
+```
+
+```tsi
+// src/main.tsi — run with: nola run src/main.tsi
+import { createTicket } from "./tickets.js";
+
+const .message = "Hi, I can't log in since this morning and I have a customer demo in an hour — please help!";
+
+const ticket = ask createTicket(..`a short ticket title`<string>, ..`priority 1-5, where 1 is most urgent`<number>);
+
+console.log(JSON.stringify(ticket));
+```
+
+`ask` yields the callee's SETTLED value — a `Ticket`, not a `Promise<Ticket>`.
+The import uses the NodeNext `./tickets.js` specifier for the on-disk
+`tickets.ts`. Note there is no first-line instruction here: an `import` is a
+statement, so a template literal placed after it is not the file's first
+statement and would be a no-op.
+
+## The typescript-interop project, end to end
+
+This is the shape a Nola library or app takes: `.tsi` files hold the infer
 functions, a plain `.ts` entry point calls them, and `nola run` executes the
-entry with the loader and `nola.config.ts` in place.
+entry with the loader and `nola.config.ts` in place (`npm create nola`
+scaffolds it as `typescript-interop`).
 
 ```
 my-app/
@@ -27,7 +102,7 @@ export interface Person {
 }
 
 export infer function extractPerson(.message: string) {
-  const person = ask ..`the person described in the text`<Person>;
+  const person = ask `the person described in the text`<Person>;
   return person;
 }
 ```
@@ -69,8 +144,8 @@ export infer function solve(.problem: string) {
   // Both asks see `problem` (the contextual parameter). They do NOT see each
   // other's answers automatically — the reasoning is handed to the second ask
   // explicitly through `${}`.
-  const reasoning = ask ..`think step by step about the problem before answering`;
-  const answer = ask ..`the final numeric answer, given this reasoning: ${reasoning}`<number>;
+  const reasoning = ask `think step by step about the problem before answering`;
+  const answer = ask `the final numeric answer, given this reasoning: ${reasoning}`<number>;
   return { reasoning, answer };
 }
 ```
@@ -83,8 +158,8 @@ later prompt:
 export type Category = "billing" | "refund" | "fraud" | "other";
 
 export infer function classifyMessage(.message: string) {
-  const category = ask ..`the category of the customer message`<Category>;
-  const urgent = ask ..`does the message need urgent attention`<"yes" | "no">;
+  const category = ask `the category of the customer message`<Category>;
+  const urgent = ask `does the message need urgent attention`<"yes" | "no">;
 
   // plain TS from here on
   if (category === "fraud") return { category, urgent: true, escalate: true };
@@ -103,11 +178,11 @@ export interface Conclusion {
 }
 
 export infer function nextQuery(.question: string, .notes: string[]) {
-  return ask ..`the single best search query to advance the research; keywords only`<string>;
+  return ask `the single best search query to advance the research; keywords only`<string>;
 }
 
 export infer function conclude(.question: string, .notes: string[]) {
-  return ask ..`answer the research question using only the collected notes`<Conclusion>;
+  return ask `answer the research question using only the collected notes`<Conclusion>;
 }
 ```
 
@@ -204,7 +279,7 @@ export interface Invoice {
 }
 
 export infer function extractInvoice(.document: string) {
-  return ask ..`the invoice data from the document`<Invoice>;
+  return ask `the invoice data from the document`<Invoice>;
 }
 ```
 
@@ -221,9 +296,9 @@ export enum Sentiment {
 }
 
 export infer function triage(.message: string) {
-  const category = ask ..`the category of the customer message`<Category>;
-  const sentiment = ask ..`the overall sentiment of the message`<Sentiment>;
-  const urgent = ask ..`does the message need urgent attention`<"yes" | "no">;
+  const category = ask `the category of the customer message`<Category>;
+  const sentiment = ask `the overall sentiment of the message`<Sentiment>;
+  const urgent = ask `does the message need urgent attention`<"yes" | "no">;
   return { category, sentiment, urgent: urgent === "yes" };
 }
 ```
@@ -248,7 +323,7 @@ export interface Person {
 import type { Person } from "./models.js";
 
 export infer function extractPerson(.text: string) {
-  return ask ..`the person described in the text`<Person>;
+  return ask `the person described in the text`<Person>;
 }
 ```
 
@@ -272,7 +347,7 @@ export type TreeNode = {
 };
 
 export infer function parseTree(.input: string) {
-  return ask ..`the tree structure described in the input`<TreeNode>;
+  return ask `the tree structure described in the input`<TreeNode>;
 }
 ```
 
@@ -282,7 +357,7 @@ export infer function parseTree(.input: string) {
 export type CalendarEvent = { title: string; at: Date };
 
 export infer function nextEvent(.calendar: string) {
-  const event = ask ..`the next event on the calendar`<CalendarEvent>;
+  const event = ask `the next event on the calendar`<CalendarEvent>;
   const when: Date = event.at;   // a Date, not a string
   return when;
 }