@pikku/cli 0.12.145 → 0.12.152

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.d.ts

@@ -1,7 +1,7 @@
 export declare const pikkuTriggerTypes: import("#pikku/function").PikkuFunctionConfig<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunction<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/wirings/triggers/pikku-command-trigger.d.ts

@@ -1 +1 @@
-export declare const pikkuTrigger: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuTrigger: import("#pikku/function").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/wirings/variables/pikku-command-variables.d.ts

@@ -1 +1 @@
-export declare const pikkuVariables: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuVariables: import("#pikku/function").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku/function").PikkuFunction<void, void, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/wirings/virtual-user/pikku-command-virtual-user-functions.d.ts

@@ -1 +1 @@
-export declare const pikkuVirtualUserFunctions: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuVirtualUserFunctions: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/wirings/webhook/pikku-command-webhook.d.ts

@@ -1 +1 @@
-export declare const pikkuWebhook: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuWebhook: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/wirings/workflow/pikku-command-workflow-routes.d.ts

@@ -1 +1 @@
-export declare const pikkuWorkflowRoutes: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuWorkflowRoutes: import("#pikku/function").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku/function").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/wirings/workflow/pikku-command-workflow.d.ts

@@ -1,5 +1,5 @@
 type WorkflowCommandInput = {
     bootstrap?: boolean;
 };
-export declare const pikkuWorkflow: import("#pikku/function").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuWorkflow: import("#pikku/function").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices> | import("#pikku/function").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku/function").WiredServices, unknown>, undefined, undefined>;
 export {};

package/dist/src/functions/workflows/all.workflow.js

@@ -16,6 +16,13 @@ const scaffoldFiles = (config) => {
         });
     if (config.scaffold?.rpc && config.publicRpcFile)
         files.push({ file: config.publicRpcFile, generator: 'pikkuPublicRPC' });
+    if (config.scaffold?.analytics && config.analyticsFile)
+        files.push({ file: config.analyticsFile, generator: 'pikkuAnalytics' });
+    if (config.scaffold?.featureFlags && config.featureFlagsFile)
+        files.push({
+            file: config.featureFlagsFile,
+            generator: 'pikkuFeatureFlagsScaffold',
+        });
     if (config.scaffold?.console && config.consoleFunctionsFile)
         files.push({
             file: config.consoleFunctionsFile,
@@ -66,14 +73,15 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             await workflow.do('Bootstrap inspect', async () => {
                 await getInspectorState(false, true, true);
             });
-            // Both before the function types: the function leaf imports ScopeId from
-            // the scopes codegen, so any later import of '#pikku/function' — the
-            // inspector reading a project's zod schemas, for one — fails until these
-            // two files exist.
+            // All before the function types: the function leaf imports ScopeId and
+            // FeatureFlagName from these, so any later import of '#pikku/function' —
+            // the inspector reading a project's zod schemas, for one — fails until
+            // they exist.
             await workflow.do('Bootstrap scope definition types', 'pikkuScopeDefinitionTypes', null);
             await workflow.do('Bootstrap error types', 'pikkuErrorTypes', null);
             await workflow.do('Bootstrap scopes', 'pikkuScopes', { bootstrap: true });
             await workflow.do('Bootstrap roles', 'pikkuRoles', { bootstrap: true });
+            await workflow.do('Bootstrap flags', 'pikkuFlags', { bootstrap: true });
             await workflow.do('Bootstrap personas', 'pikkuPersonas', {
                 bootstrap: true,
             });
@@ -140,6 +148,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         await Promise.all([
             workflow.do('Secret definition types', 'pikkuSecretDefinitionTypes', null),
             workflow.do('Scope definition types', 'pikkuScopeDefinitionTypes', null),
+            workflow.do('Analytics definition types', 'pikkuAnalyticsDefinitionTypes', null),
             workflow.do('Variable definition types', 'pikkuVariableDefinitionTypes', null),
         ]);
         await workflow.do('Function types split', 'pikkuFunctionTypesSplit', {});
@@ -204,6 +213,8 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         await Promise.all([
             workflow.do('Graph wirings', 'pikkuGraphWirings', null),
             workflow.do('Public RPC', 'pikkuPublicRPC', null),
+            workflow.do('Analytics ingest', 'pikkuAnalytics', null),
+            workflow.do('Feature flag wire', 'pikkuFeatureFlagsScaffold', null),
             workflow.do('Console functions', 'pikkuConsoleFunctions', null),
             workflow.do('Virtual user functions', 'pikkuVirtualUserFunctions', null),
             workflow.do('Events scaffold', 'pikkuEventsScaffold', null),
@@ -214,6 +225,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
             workflow.do('Credentials', 'pikkuCredentials', null),
             workflow.do('Scopes', 'pikkuScopes', {}),
             workflow.do('Roles', 'pikkuRoles', {}),
+            workflow.do('Flags', 'pikkuFlags', {}),
             workflow.do('Personas', 'pikkuPersonas', {}),
             workflow.do('Variables', 'pikkuVariables', null),
             workflow.do('Addon types', 'pikkuAddonTypes', null),
@@ -234,14 +246,29 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         // Re-inspect above — are reflected in pikku-secrets-meta.gen.json. Without
         // this the declaration only lands on a second `pikku` run, and a cold
         // project deploys without ever being asked for the value.
+        //
+        // Middleware is in the same boat and fails far louder: pikkuAuth writes
+        // auth-middleware.gen.ts, whose top-level addGlobalMiddleware registers the
+        // better-auth session bridge. The Middleware pass above ran before that file
+        // existed, so pikku-middleware.gen.ts — the only thing that side-effect
+        // imports it — leaves it out, and a first-ever build ships with NO session
+        // middleware at all: every session-requiring function answers
+        // 'Authentication required' however the caller authenticated. It corrects
+        // itself on the next run, which is why it only ever bites a clean checkout
+        // (a CI deploy that wipes generated scaffolds, most of all).
         const stateAfterScaffold = await getInspectorState();
         if (stateAfterScaffold.auth.definition ||
             stateAfterScaffold.personas.definitions.length > 0) {
-            await Promise.all([
+            const [, , , middlewareAfterScaffold] = await Promise.all([
                 workflow.do('Secrets (post-scaffold)', 'pikkuSecrets', null),
                 workflow.do('Credentials (post-scaffold)', 'pikkuCredentials', null),
                 workflow.do('Variables (post-scaffold)', 'pikkuVariables', null),
+                workflow.do('Middleware (post-scaffold)', 'pikkuMiddleware', null),
             ]);
+            if (middlewareAfterScaffold &&
+                !allImports.includes(config.middlewareFile)) {
+                allImports.push(config.middlewareFile);
+            }
         }
         const schemas = await workflow.do('Schemas', 'pikkuSchemas', null);
         if (schemas) {
@@ -415,10 +442,8 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         // (like assertSingleCoreVersion) so it reliably fails the run.
         if (config.tsc || config.tscSummary) {
             const errorCount = await workflow.do('Type check', async () => {
-                const { result, diagnostics, formatHost } = runProjectTypecheck(config.tsconfig, config.rootDir);
-                logger.info(config.tsc
-                    ? renderTscFull(diagnostics, config.rootDir, formatHost)
-                    : renderTscSummary(result));
+                const result = runProjectTypecheck(config.tsconfig, config.rootDir);
+                logger.info(config.tsc ? renderTscFull(result) : renderTscSummary(result));
                 return result.errorCount;
             });
             if (errorCount > 0) {

package/dist/src/services.js

@@ -249,6 +249,13 @@ export const createSingletonServices = async (config) => {
                 config.workflowRoutesFile,
                 config.publicRpcFile,
                 config.publicAgentFile,
+                // The analytics ingest is generated into the scaffold dir and nothing
+                // imports it — it is a wiring, not a module anyone calls — so without
+                // this the route is written and never registered: no HTTP wiring, no
+                // entry in the fetch client, an endpoint that 404s.
+                config.analyticsFile,
+                // Same for the feature flag read wire.
+                config.featureFlagsFile,
                 // The auth scaffold (catch-all routes + session middleware) and its
                 // sibling secrets file (defineSecret per provider) are generated into the
                 // scaffold dir, which may live outside srcDirectories (e.g. a project's

package/dist/src/utils/analytics-schemas-file.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The schemas module always sits beside the ingest that imports it, so there is
+ * nothing to configure: a settable path could be moved out from under the
+ * generated `./analytics.schemas.gen.js` import and nothing would write it.
+ */
+export declare const analyticsSchemasFile: (analyticsFile: string | undefined) => string | undefined;

package/dist/src/utils/analytics-schemas-file.js

@@ -0,0 +1,9 @@
+import { dirname, join } from 'node:path';
+/**
+ * The schemas module always sits beside the ingest that imports it, so there is
+ * nothing to configure: a settable path could be moved out from under the
+ * generated `./analytics.schemas.gen.js` import and nothing would write it.
+ */
+export const analyticsSchemasFile = (analyticsFile) => analyticsFile
+    ? join(dirname(analyticsFile), 'analytics.schemas.gen.ts')
+    : undefined;

package/dist/src/utils/file-import-path.js

@@ -19,7 +19,10 @@ forceRelative = false) => {
     }
     const posixPath = filePath.replace(/\\/g, '/');
     if (posixPath.includes('node_modules/')) {
-        const nodeModulesIndex = posixPath.indexOf('node_modules/');
+        // An isolated store (bun's node_modules/.bun, pnpm's node_modules/.pnpm)
+        // nests a second node_modules inside the first, so the package specifier
+        // follows the last separator rather than the first.
+        const nodeModulesIndex = posixPath.lastIndexOf('node_modules/');
         filePath = posixPath.substring(nodeModulesIndex + 'node_modules/'.length);
         if (filePath.startsWith('@types/')) {
             filePath = filePath.substring('@types/'.length);

package/dist/src/utils/pikku-cli-config.d.ts

@@ -24,7 +24,7 @@ export { PikkuCLIConfigError };
  * exact leak the split exists to prevent, silently, and only in a deployed
  * bundle. Nothing downstream can detect it, so it is rejected here.
  */
-export declare const assertSchemaDirectoriesAreDistinct: (config: Pick<PikkuCLIConfig, "schemaDirectory" | "scenarioSchemaDirectory">) => void;
+export declare const assertSchemaDirectoriesAreDistinct: (config: Pick<PikkuCLIConfig, 'schemaDirectory' | 'scenarioSchemaDirectory'>) => void;
 /**
  * The `metaLocale` a project gets when its config does not name one.
  *
@@ -51,5 +51,5 @@ export declare const normalizeMetaLocale: (metaLocale: unknown) => string;
  * stored `/app/` matches nothing at all — a frontend that silently never
  * appears rather than an error anyone can act on.
  */
-export declare const resolveFrontendConfig: (frontend: NonNullable<PikkuCLIInput["frontend"]>, configDir: string) => NonNullable<PikkuCLIConfig["frontend"]>;
+export declare const resolveFrontendConfig: (frontend: NonNullable<PikkuCLIInput['frontend']>, configDir: string) => NonNullable<PikkuCLIConfig['frontend']>;
 export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

package/dist/src/utils/pikku-cli-config.js

@@ -383,6 +383,8 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         // setting it here wins and the pikkuDir-derived default is skipped.
         const SCAFFOLD_OUTPUT_FIELDS = {
             rpc: 'publicRpcFile',
+            analytics: 'analyticsFile',
+            featureFlags: 'featureFlagsFile',
             agent: 'publicAgentFile',
             console: 'consoleFunctionsFile',
             scenarios: 'scenariosFunctionsFile',
@@ -425,6 +427,12 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (result.scaffold?.workflow && !result.workflowRoutesSchemasFile) {
             result.workflowRoutesSchemasFile = join(resolvedScaffoldDir, 'workflow', 'workflow-routes.schemas.gen.ts');
         }
+        if (result.scaffold?.analytics && !result.analyticsFile) {
+            result.analyticsFile = join(resolvedScaffoldDir, 'analytics', 'analytics.gen.ts');
+        }
+        if (result.scaffold?.featureFlags && !result.featureFlagsFile) {
+            result.featureFlagsFile = join(resolvedScaffoldDir, 'feature-flags', 'feature-flags.gen.ts');
+        }
         if (result.scaffold?.rpc && !result.publicRpcFile) {
             result.publicRpcFile = join(resolvedScaffoldDir, 'rpc', 'rpc-public.gen.ts');
         }
@@ -713,6 +721,18 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.credentialsMetaJsonFile) {
             result.credentialsMetaJsonFile = join(credentialsDir, 'pikku-credentials-meta.gen.json');
         }
+        // Analytics definer leaf. Written whatever `scaffold.analytics` says: the
+        // declaration is how a project names what it measures, and the scaffold
+        // only decides whether an ingest wire is generated for it.
+        if (!result.analyticsTypesFile) {
+            result.analyticsTypesFile = join(result.outDir, 'analytics', 'pikku-analytics-types.gen.ts');
+        }
+        // The declared events, for the console's catalog. Written on the same terms
+        // as the definer leaf and for the same reason: what a project measures is
+        // readable whether or not an ingest wire was scaffolded for it.
+        if (!result.analyticsMetaJsonFile) {
+            result.analyticsMetaJsonFile = join(result.outDir, 'analytics', 'pikku-analytics-meta.gen.json');
+        }
         // Scopes (ScopeId union + declared scope set)
         const scopesDir = join(result.outDir, 'scopes');
         if (!result.scopeTypesFile) {
@@ -732,6 +752,14 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
         if (!result.rolesMetaJsonFile) {
             result.rolesMetaJsonFile = join(scopesDir, 'pikku-roles-meta.gen.json');
         }
+        // Feature flags. Beside the scopes their `anyOf` names, for the same reason
+        // roles sit there: a flag is unreadable without them.
+        if (!result.flagsFile) {
+            result.flagsFile = join(scopesDir, 'pikku-flags.gen.ts');
+        }
+        if (!result.flagsMetaJsonFile) {
+            result.flagsMetaJsonFile = join(scopesDir, 'pikku-flags-meta.gen.json');
+        }
         // Personas. Beside the roles they are checked against, for the same reason
         // roles sit beside their scopes.
         if (!result.personasFile) {

package/dist/src/utils/remove-legacy-scaffold-file.js

@@ -2,6 +2,7 @@ import { rm } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { remoteJobsSchemasFile } from './remote-jobs-schemas-file.js';
+import { analyticsSchemasFile } from './analytics-schemas-file.js';
 const scaffoldFiles = (config) => {
     const authDir = config.authFile ? dirname(config.authFile) : undefined;
     return [
@@ -12,6 +13,9 @@ const scaffoldFiles = (config) => {
         config.workflowRoutesSchemasFile,
         config.publicRpcFile,
         config.publicRpcSchemasFile,
+        config.analyticsFile,
+        analyticsSchemasFile(config.analyticsFile),
+        config.featureFlagsFile,
         config.remoteRpcWorkersFile,
         config.remoteRpcSchemasFile,
         config.remoteJobsFile,

package/dist/src/utils/resolve-from-project.d.ts

@@ -9,6 +9,11 @@
  * skew surfaces as a missing subpath export from a package the project never
  * imported. Resolving against the project's own package.json keeps one core in
  * play.
+ *
+ * Only an absolute path is a copy in the project. A runtime that hands a bare
+ * specifier straight back — bun does this for the modules it implements itself,
+ * `ws` among them — has resolved nothing from the project, and saying so lets
+ * the caller fall back rather than import the runtime's own copy by accident.
  */
 export declare const resolveFromProject: (rootDir: string, specifier: string) => string | undefined;
 /**

package/dist/src/utils/resolve-from-project.js

@@ -1,5 +1,5 @@
 import { createRequire } from 'node:module';
-import { join } from 'node:path';
+import { isAbsolute, join } from 'node:path';
 /**
  * Resolves a package as the *project* would, not as the CLI would.
  *
@@ -11,10 +11,16 @@ import { join } from 'node:path';
  * skew surfaces as a missing subpath export from a package the project never
  * imported. Resolving against the project's own package.json keeps one core in
  * play.
+ *
+ * Only an absolute path is a copy in the project. A runtime that hands a bare
+ * specifier straight back — bun does this for the modules it implements itself,
+ * `ws` among them — has resolved nothing from the project, and saying so lets
+ * the caller fall back rather than import the runtime's own copy by accident.
  */
 export const resolveFromProject = (rootDir, specifier) => {
     try {
-        return createRequire(join(rootDir, 'package.json')).resolve(specifier);
+        const resolved = createRequire(join(rootDir, 'package.json')).resolve(specifier);
+        return isAbsolute(resolved) ? resolved : undefined;
     }
     catch {
         return undefined;

package/dist/src/utils/tsc-check.d.ts

@@ -1,4 +1,3 @@
-import ts from 'typescript';
 import { PikkuError } from '@pikku/core/errors';
 export declare class PikkuTypecheckFailedError extends PikkuError {
 }
@@ -17,12 +16,13 @@ export interface TscCheckResult {
     diagnostics: TscDiagnostic[];
 }
 /**
- * Turn raw tsc diagnostics into a filtered, structured result. Pure — it takes
- * already-computed diagnostics so it can be unit-tested without a program.
- * Anything under node_modules or outside the project root is dropped so the
- * output stays focused on the user's own code (and not lib .d.ts noise).
+ * Turn raw `tsc --pretty false` output into a filtered, structured result.
+ * Pure — it takes already-captured output so it can be unit-tested without
+ * running a compiler. Anything under node_modules or outside the project root
+ * is dropped so the output stays focused on the user's own code (and not lib
+ * .d.ts noise).
  */
-export declare const collectTscDiagnostics: (diagnostics: readonly ts.Diagnostic[], rootDir: string) => TscCheckResult;
+export declare const parseTscOutput: (output: string, rootDir: string) => TscCheckResult;
 /**
  * Compact, token-frugal render of a type-check result: a one-line header plus
  * one line per diagnostic (no code frames), capped. Used by `--tsc-summary` so
@@ -30,17 +30,13 @@ export declare const collectTscDiagnostics: (diagnostics: readonly ts.Diagnostic
  */
 export declare const renderTscSummary: (result: TscCheckResult, maxLines?: number) => string;
 /**
- * Full render: tsc's own formatter with code frames, filtered to project files.
+ * Full render: every project diagnostic, uncapped, one per line.
  */
-export declare const renderTscFull: (diagnostics: readonly ts.Diagnostic[], rootDir: string, formatHost: ts.FormatDiagnosticsHost) => string;
+export declare const renderTscFull: (result: TscCheckResult) => string;
 /**
  * Run a real `tsc --noEmit` over the project's own tsconfig — the correct
  * source of truth (lib, paths, strict), unlike the inspector's stripped-down
- * traversal program. Returns both a structured result and the raw diagnostics
- * so the caller can pick the compact (`--tsc-summary`) or full (`--tsc`) render.
+ * traversal program. Returns the structured result so the caller can pick the
+ * compact (`--tsc-summary`) or full (`--tsc`) render.
  */
-export declare const runProjectTypecheck: (tsconfigPath: string, rootDir: string) => {
-    result: TscCheckResult;
-    diagnostics: ts.Diagnostic[];
-    formatHost: ts.FormatDiagnosticsHost;
-};
+export declare const runProjectTypecheck: (tsconfigPath: string, rootDir: string) => TscCheckResult;

package/dist/src/utils/tsc-check.js

@@ -1,33 +1,18 @@
-import ts from 'typescript';
-import { dirname, isAbsolute, join, relative } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { createRequire } from 'node:module';
 import { PikkuError } from '@pikku/core/errors';
-// Type-check with the PROJECT's own TypeScript when it has one — the CLI's
-// bundled compiler can be a different major (e.g. TS 6 vs a project on TS 5)
-// and produce diagnostics the project's real `tsc` never would (seen as
-// phantom TS2591 "Cannot find name 'process'" on a tsconfig that is clean
-// under the project's compiler). Falls back to the CLI's typescript.
-const loadProjectTs = (rootDir) => {
-    try {
-        return createRequire(join(rootDir, 'noop.cjs'))('typescript');
-    }
-    catch {
-        return ts;
-    }
-};
 // A type-check failure is expected (the --tsc gate did its job) — throw a
 // PikkuError so the runner logs the message alone, not a stack trace.
 export class PikkuTypecheckFailedError extends PikkuError {
 }
-const CATEGORY = {
-    [ts.DiagnosticCategory.Error]: 'error',
-    [ts.DiagnosticCategory.Warning]: 'warning',
-    [ts.DiagnosticCategory.Suggestion]: 'suggestion',
-    [ts.DiagnosticCategory.Message]: 'message',
-};
 const MAX_MESSAGE_LENGTH = 200;
 const DEFAULT_MAX_LINES = 50;
 const NO_FILE = '(project)';
+const MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
+// `<file>(<line>,<col>): <category> TS<code>: <message>`, with the location
+// absent on project-wide diagnostics such as TS18003 (no inputs found).
+const DIAGNOSTIC_LINE = /^(?:(.+?)\((\d+),(\d+)\): )?(error|warning|message|suggestion) TS(\d+): (.*)$/;
 const isProjectFile = (fileName, rootDir) => {
     if (fileName.includes('/node_modules/'))
         return false;
@@ -35,40 +20,94 @@ const isProjectFile = (fileName, rootDir) => {
     return !rel.startsWith('..') && !isAbsolute(rel);
 };
 /**
- * Turn raw tsc diagnostics into a filtered, structured result. Pure — it takes
- * already-computed diagnostics so it can be unit-tested without a program.
- * Anything under node_modules or outside the project root is dropped so the
- * output stays focused on the user's own code (and not lib .d.ts noise).
+ * Locate the compiler to type-check with, preferring the PROJECT's own — a
+ * different major than the project's produces diagnostics its real `tsc` never
+ * would (seen as phantom TS2591 "Cannot find name 'process'" on a tsconfig that
+ * is clean under the project's compiler). Falls back to the CLI's typescript.
+ *
+ * Resolved through `typescript/package.json` rather than `node_modules/.bin`
+ * so it works on every platform, and run with `process.execPath` so a project
+ * on TypeScript 7 — which ships a binary but no importable compiler API — is
+ * driven exactly like one on 5 or 6.
+ */
+const resolveTsc = (rootDir) => {
+    const fromProject = createRequire(join(rootDir, 'noop.cjs'));
+    try {
+        return join(dirname(fromProject.resolve('typescript/package.json')), 'bin', 'tsc');
+    }
+    catch {
+        const own = createRequire(import.meta.url);
+        return join(dirname(own.resolve('typescript/package.json')), 'bin', 'tsc');
+    }
+};
+/**
+ * Turn raw `tsc --pretty false` output into a filtered, structured result.
+ * Pure — it takes already-captured output so it can be unit-tested without
+ * running a compiler. Anything under node_modules or outside the project root
+ * is dropped so the output stays focused on the user's own code (and not lib
+ * .d.ts noise).
  */
-export const collectTscDiagnostics = (diagnostics, rootDir) => {
+export const parseTscOutput = (output, rootDir) => {
     const files = new Set();
     const collected = [];
     let errorCount = 0;
     let warningCount = 0;
-    for (const d of diagnostics) {
-        let file = NO_FILE;
-        let line = 0;
-        let column = 0;
-        if (d.file) {
-            if (!isProjectFile(d.file.fileName, rootDir))
-                continue;
-            file = relative(rootDir, d.file.fileName);
-            const lc = d.file.getLineAndCharacterOfPosition(d.start ?? 0);
-            line = lc.line + 1;
-            column = lc.character + 1;
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.message.length > MAX_MESSAGE_LENGTH) {
+            current.message = `${current.message.slice(0, MAX_MESSAGE_LENGTH - 1)}…`;
         }
-        const category = CATEGORY[d.category];
-        if (category === 'error')
+        if (current.category === 'error')
             errorCount++;
-        else if (category === 'warning')
+        else if (current.category === 'warning')
             warningCount++;
-        let message = ts.flattenDiagnosticMessageText(d.messageText, ' ');
-        if (message.length > MAX_MESSAGE_LENGTH) {
-            message = `${message.slice(0, MAX_MESSAGE_LENGTH - 1)}…`;
+        files.add(current.file);
+        collected.push(current);
+        current = null;
+    };
+    for (const raw of output.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        const match = DIAGNOSTIC_LINE.exec(line);
+        if (match) {
+            flush();
+            const [, fileName, lineNo, columnNo, category, code, message] = match;
+            if (fileName) {
+                const absolute = isAbsolute(fileName)
+                    ? fileName
+                    : resolve(rootDir, fileName);
+                // Skip the whole diagnostic, elaborations included.
+                if (!isProjectFile(absolute, rootDir))
+                    continue;
+                current = {
+                    file: relative(rootDir, absolute),
+                    line: Number(lineNo),
+                    column: Number(columnNo),
+                    code: Number(code),
+                    category: category,
+                    message: message ?? '',
+                };
+            }
+            else {
+                current = {
+                    file: NO_FILE,
+                    line: 0,
+                    column: 0,
+                    code: Number(code),
+                    category: category,
+                    message: message ?? '',
+                };
+            }
+            continue;
+        }
+        // Indented lines continue the previous message (tsc's elaborations);
+        // anything else — blank lines, the trailing "Found N errors" — is noise.
+        if (current && /^\s+\S/.test(line)) {
+            current.message = `${current.message} ${line.trim()}`;
         }
-        files.add(file);
-        collected.push({ file, line, column, code: d.code, category, message });
     }
+    flush();
     collected.sort((a, b) => a.file === b.file ? a.line - b.line : a.file < b.file ? -1 : 1);
     return {
         errorCount,
@@ -107,53 +146,25 @@ export const renderTscSummary = (result, maxLines = DEFAULT_MAX_LINES) => {
     return lines.join('\n');
 };
 /**
- * Full render: tsc's own formatter with code frames, filtered to project files.
+ * Full render: every project diagnostic, uncapped, one per line.
  */
-export const renderTscFull = (diagnostics, rootDir, formatHost) => {
-    const filtered = diagnostics.filter((d) => !d.file || isProjectFile(d.file.fileName, rootDir));
-    if (filtered.length === 0)
+export const renderTscFull = (result) => {
+    if (result.diagnostics.length === 0)
         return 'Type check passed — no errors.';
-    return ts.formatDiagnosticsWithColorAndContext(filtered, formatHost);
+    return result.diagnostics
+        .map((d) => {
+        const at = d.line > 0 ? `${d.file}:${d.line}:${d.column}` : d.file;
+        return `${at}  TS${d.code}  ${d.message}`;
+    })
+        .join('\n');
 };
 /**
  * Run a real `tsc --noEmit` over the project's own tsconfig — the correct
  * source of truth (lib, paths, strict), unlike the inspector's stripped-down
- * traversal program. Returns both a structured result and the raw diagnostics
- * so the caller can pick the compact (`--tsc-summary`) or full (`--tsc`) render.
+ * traversal program. Returns the structured result so the caller can pick the
+ * compact (`--tsc-summary`) or full (`--tsc`) render.
  */
 export const runProjectTypecheck = (tsconfigPath, rootDir) => {
-    const tsImpl = loadProjectTs(rootDir);
-    const formatHost = {
-        getCanonicalFileName: (f) => f,
-        getCurrentDirectory: () => rootDir,
-        getNewLine: () => tsImpl.sys.newLine,
-    };
-    const configFile = tsImpl.readConfigFile(tsconfigPath, tsImpl.sys.readFile);
-    if (configFile.error) {
-        const diagnostics = [configFile.error];
-        return {
-            result: collectTscDiagnostics(diagnostics, rootDir),
-            diagnostics,
-            formatHost,
-        };
-    }
-    const parsed = tsImpl.parseJsonConfigFileContent(configFile.config, tsImpl.sys, dirname(tsconfigPath));
-    const program = tsImpl.createProgram({
-        rootNames: parsed.fileNames,
-        options: {
-            ...parsed.options,
-            noEmit: true,
-            incremental: false,
-            tsBuildInfoFile: undefined,
-        },
-    });
-    const diagnostics = [
-        ...parsed.errors,
-        ...tsImpl.getPreEmitDiagnostics(program),
-    ];
-    return {
-        result: collectTscDiagnostics(diagnostics, rootDir),
-        diagnostics,
-        formatHost,
-    };
+    const run = spawnSync(process.execPath, [resolveTsc(rootDir), '-p', tsconfigPath, '--noEmit', '--pretty', 'false'], { cwd: rootDir, encoding: 'utf8', maxBuffer: MAX_OUTPUT_BYTES });
+    return parseTscOutput(`${run.stdout ?? ''}\n${run.stderr ?? ''}`, rootDir);
 };