toiljs 0.0.113 → 0.0.115

package/src/cli/updates.ts

@@ -50,6 +50,29 @@ export function parseNcuJson(stdout: string): Record<string, string> {
     }
 }
 
+/**
+ * Majors `toiljs update` refuses to upgrade into, by package. TypeScript 7 is the native (Go) port:
+ * it ships `tsc` but no JavaScript compiler API, which toiljs's route-metadata extractor, the eslint
+ * preset, and typedoc all load. Upgrading into it silently stops SEO metadata being baked into the
+ * built HTML and hard-crashes typescript-eslint, so the upgrade is withheld until the ecosystem
+ * catches up. Bumps *within* the supported major are still offered.
+ */
+export const UNSUPPORTED_MAJOR: Readonly<Record<string, number>> = { typescript: 7 };
+
+/**
+ * The names ncu wants to upgrade into a major toiljs does not support (see {@link UNSUPPORTED_MAJOR}).
+ * These are dropped from the picker and passed to ncu's `--reject`, so `-u` cannot apply them either.
+ */
+export function withheldUpgrades(upgraded: Record<string, string>): string[] {
+    return Object.entries(upgraded)
+        .filter(([name, to]) => {
+            const ceiling = UNSUPPORTED_MAJOR[name];
+            return ceiling !== undefined && parseVersion(to)[0] >= ceiling;
+        })
+        .map(([name]) => name)
+        .sort();
+}
+
 const SEVERITY: Record<Bump, number> = { major: 0, minor: 1, patch: 2, other: 3 };
 
 /**

package/src/compiler/index.ts

@@ -308,9 +308,18 @@ export async function buildServer(root: string, auth: boolean = false): Promise<
         return;
     }
 
-    // Default request-only single-artifact path (no daemon/stream surface).
+    // Default request-only single-artifact path (no daemon/stream surface). Declare `hot` rather
+    // than leaving --targetMode off: with no explicit mode toilscript treats a source tree that
+    // declares no surface decorator as a plain AssemblyScript compile and omits `toil.surface`
+    // (to keep an ordinary AS build byte-identical). A toiljs server IS a Toil request artifact
+    // even before it grows its first `@rest`/`@data`, and the host refuses to load an artifact
+    // without that section, so a freshly scaffolded app would never deploy. `hot` is the mode the
+    // section already records for the default request artifact, so the bytes are unchanged for a
+    // project that has a surface; it only stops the section from going missing for one that
+    // doesn't. (`@daemon`/`@scheduled` are the only decorators `hot` rejects, and this branch runs
+    // exactly when the tree has neither.)
     await runToilscriptPass(root, binJs, files, {
-        mode: null,
+        mode: 'hot',
         outFile: null,
         withRpc: true,
         authUser: authOn,

package/src/compiler/pages.ts

@@ -1,13 +1,6 @@
-import { createRequire } from 'node:module';
-import path from 'node:path';
-
-import type * as TS from 'typescript';
-
-import { extractStaticExports } from './prerender.js';
+import { extractStaticExports, loadTypeScriptSync } from './prerender.js';
 import type { ScannedRoute } from './routes.js';
 
-type Ts = typeof TS;
-
 /**
  * A page in the build-time search index: its URL pattern, whether it's dynamic, and the
  * statically-extracted `metadata` literal (the searchable subset; dynamic `generateMetadata` and
@@ -20,20 +13,6 @@ export interface PageIndexEntry {
     readonly metadata: Record<string, unknown>;
 }
 
-/**
- * Loads the project's TypeScript synchronously (so {@link buildPageIndex} can run inside the sync
- * `generate()`), or `null` if it isn't installed, in which case pages are indexed by path only.
- */
-function loadTypeScriptSync(root: string): Ts | null {
-    try {
-        const require = createRequire(path.join(root, 'package.json'));
-        const mod = require('typescript') as { default?: Ts } & Ts;
-        return mod.default ?? mod;
-    } catch {
-        return null;
-    }
-}
-
 /** True when a route pattern has dynamic (`:param` / `*catch-all`) segments. */
 function isDynamic(pattern: string): boolean {
     return /[:*]/.test(pattern);

package/src/compiler/prerender.ts

@@ -12,15 +12,69 @@ import { injectSeoHtml, routeSeo } from './seo.js';
 
 type Ts = typeof TS;
 
-/** Loads the project's TypeScript (used to read each route's static `metadata`), or `null` if absent. */
+/**
+ * True when `mod` exposes the classic TypeScript compiler API the static extractor drives.
+ *
+ * Resolving `typescript` is not enough to know it can parse: TypeScript 7 (the native port) moved
+ * the compiler API off the package's main entry, which now exports only `version`. That module is a
+ * perfectly good object, so a truthy check passes and the first `ts.ScriptTarget.Latest` then dies
+ * with `Cannot read properties of undefined (reading 'Latest')`. Probe the members we actually use.
+ */
+function isCompilerApi(mod: unknown): mod is Ts {
+    const ts = mod as Partial<Ts> | null | undefined;
+    return (
+        typeof ts?.createSourceFile === 'function' &&
+        typeof ts.isVariableStatement === 'function' &&
+        typeof ts.ScriptTarget === 'object' &&
+        typeof ts.ScriptKind === 'object' &&
+        typeof ts.SyntaxKind === 'object'
+    );
+}
+
+/** Warn once per process: an unusable TypeScript silently costs baked metadata, so say so. */
+let warnedUnusable = false;
+function warnUnusableTypeScript(mod: unknown): void {
+    if (warnedUnusable) return;
+    warnedUnusable = true;
+    const version = (mod as { version?: string } | null)?.version;
+    process.stderr.write(
+        `  toil: typescript${version ? `@${version}` : ''} does not expose the compiler API ` +
+            `(TypeScript 7 moved it to 'typescript/unstable/*').\n` +
+            `  toil: route metadata will NOT be baked into the built HTML. Install typescript ^6 to restore it.\n`,
+    );
+}
+
+/**
+ * Resolves the project's TypeScript, used to read each route's static `metadata`. Returns `null`
+ * when it isn't installed (callers then index pages by path only) *or* when the resolved version
+ * doesn't expose the compiler API, which is warned about rather than crashing the build.
+ */
 export async function loadTypeScript(root: string): Promise<Ts | null> {
+    let mod: unknown;
     try {
         const resolved = createRequire(path.join(root, 'package.json')).resolve('typescript');
-        const mod = (await import(pathToFileURL(resolved).href)) as { default?: Ts } & Ts;
-        return mod.default ?? mod;
+        const ns = (await import(pathToFileURL(resolved).href)) as { default?: Ts } & Ts;
+        mod = ns.default ?? ns;
+    } catch {
+        return null;
+    }
+    if (isCompilerApi(mod)) return mod;
+    warnUnusableTypeScript(mod);
+    return null;
+}
+
+/** The sync twin of {@link loadTypeScript}, for callers that can't await (e.g. `buildPageIndex`). */
+export function loadTypeScriptSync(root: string): Ts | null {
+    let mod: unknown;
+    try {
+        mod = createRequire(path.join(root, 'package.json'))('typescript');
     } catch {
         return null;
     }
+    const ts = (mod as { default?: Ts })?.default ?? mod;
+    if (isCompilerApi(ts)) return ts;
+    warnUnusableTypeScript(ts);
+    return null;
 }
 
 /** Marks an AST node that isn't a static literal (so its value can't be baked at build). */