tungsten 0.4.8 → 0.4.10

package/dist/frameworkConfigSchema.js

@@ -1,67 +1,54 @@
-import { type as arkType } from 'arktype';
-const babelParserOptionsType = arkType({
-  'allowImportExportEverywhere?': 'boolean',
-  'allowAwaitOutsideFunction?': 'boolean',
-  'allowReturnOutsideFunction?': 'boolean',
-  'allowNewTargetOutsideFunction?': 'boolean',
-  'allowSuperOutsideMethod?': 'boolean',
-  'allowUndeclaredExports?': 'boolean',
-  'annexB?': 'boolean',
-  'attachComment?': 'boolean',
-  'errorRecovery?': 'boolean',
-  'sourceType?': '"script" | "module" | "unambiguous"',
-  'sourceFilename?': 'string',
-  'startLine?': 'number',
-  'startColumn?': 'number',
-  //'plugins?': ParserPlugin[]
-  'plugins?': 'unknown[]',
-  'strictMode?': 'boolean',
-  'ranges?': 'boolean',
-  'tokens?': ' boolean',
-  'createParenthesizedExpressions?': 'boolean',
-  'createImportExpressions?': 'boolean'
-});
-const frameworkConfigBaseValidator = arkType({
-  'codeDir?': 'string',
-  'copy?': 'string',
-  'exclude?': 'string',
-  'copyExclude?': 'string',
-  'sourceDir?': 'string',
-  'publicDir?': 'string',
-  'assetsDir?': 'string',
-  'styleImportBase?': 'string',
-  //publicDir?: string
-  //siteBasePath?: "" | `/${string}`,
-  'siteBasePath?': '"" | /^\\/.*$/',
-  'clientSideNav?': 'boolean',
-  'staticSite?': 'boolean',
+// exactOptional, not optional, throughout: tsconfig has exactOptionalPropertyTypes, and optional()
+// widens the value to include undefined, which FrameworkConfig's consumers then reject
+import * as v from 'valibot';
+// shape only - babel validates its own options, and a hand-copied key list just drifts from theirs
+const babelParserOptionsSchema = v.pipe(v.looseObject({}),
+// eslint-disable-next-line no-type-assertion/no-type-assertion -- see above
+v.transform(options => options));
+const stringOrStrings = v.union([v.string(), v.array(v.string())]);
+const frameworkConfigBaseEntries = {
+  codeDir: v.exactOptional(v.string()),
+  copy: v.exactOptional(v.string()),
+  exclude: v.exactOptional(v.string()),
+  copyExclude: v.exactOptional(v.string()),
+  sourceDir: v.exactOptional(v.string()),
+  publicDir: v.exactOptional(v.string()),
+  assetsDir: v.exactOptional(v.string()),
+  styleImportBase: v.exactOptional(v.string()),
+  // valibot has no template-literal schema, so the regex proves what the cast then states
+  siteBasePath: v.exactOptional(v.pipe(v.union([v.literal(''), v.pipe(v.string(), v.regex(/^\/.*$/))]),
+  // eslint-disable-next-line no-type-assertion/no-type-assertion -- see above
+  v.transform(path => path))),
+  clientSideNav: v.exactOptional(v.boolean()),
+  staticSite: v.exactOptional(v.boolean()),
   // not ready // uniqueComponents?: boolean
   // not ready // bindMode?: BindMode
-  //appLocation: AppLocation
-  //useRootComponent: boolean
-  //rootComponent?: string
-  'routesLocation?': ['string', 'string'],
-  'envSchemasLocation?': 'string',
-  'babelOptions?': babelParserOptionsType,
-  'packageSystem?': '"rewrites" | "aliases"',
-  'ignoreDirs?': 'string | string[]',
+  routesLocation: v.exactOptional(v.tuple([v.string(), v.string()])),
+  envSchemasLocation: v.exactOptional(v.string()),
+  babelOptions: v.exactOptional(babelParserOptionsSchema),
+  packageSystem: v.exactOptional(v.picklist(['rewrites', 'aliases'])),
+  ignoreDirs: v.exactOptional(stringOrStrings),
   // rename to ignoreFolders?
-  'ignorePatterns?': 'string | string[]',
-  'skipPackageCompilation?': 'string | string[]',
-  'serverMiddleware?': ['string', 'string', 'string'],
-  'apiRoutes?': 'string',
-  'apiPath?': 'string',
-  'csr?': 'boolean'
-});
-const frameworkConfigWithRootComponentValidator = arkType({
-  '...': frameworkConfigBaseValidator,
-  // in an intersection, non-overlapping values at isAdmin would result in a ParseError
-  'useRootComponent?': 'true',
-  rootComponent: 'string'
+  ignorePatterns: v.exactOptional(stringOrStrings),
+  // test files: left out of every compile unless `tungsten compile --tests` asks for them -
+  // the same two shapes as ignoreDirs/ignorePatterns
+  testDirs: v.exactOptional(stringOrStrings),
+  testPatterns: v.exactOptional(stringOrStrings),
+  skipPackageCompilation: v.exactOptional(stringOrStrings),
+  serverMiddleware: v.exactOptional(v.tuple([v.string(), v.string(), v.string()])),
+  apiRoutes: v.exactOptional(v.string()),
+  apiPath: v.exactOptional(v.string()),
+  csr: v.exactOptional(v.boolean())
+};
+const frameworkConfigWithRootComponentSchema = v.object({
+  ...frameworkConfigBaseEntries,
+  useRootComponent: v.exactOptional(v.literal(true)),
+  rootComponent: v.string()
 });
-const frameworkConfigWithoutRootComponentValidator = arkType({
-  '...': frameworkConfigBaseValidator,
-  // in an intersection, non-overlapping values at isAdmin would result in a ParseError
-  'useRootComponent': 'false'
+const frameworkConfigWithoutRootComponentSchema = v.object({
+  ...frameworkConfigBaseEntries,
+  useRootComponent: v.literal(false)
 });
-export const frameworkConfigValidator = frameworkConfigWithRootComponentValidator.or(frameworkConfigWithoutRootComponentValidator);
+// variant, not union: a plain union reports one issue at the union itself ("Expected Object but
+// received Object"), where this picks the branch by useRootComponent and reports its actual fields
+export const frameworkConfigValidator = v.variant('useRootComponent', [frameworkConfigWithRootComponentSchema, frameworkConfigWithoutRootComponentSchema]);

package/dist/getUserConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUserConfig.d.ts","sourceRoot":"","sources":["../src/getUserConfig.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAMxF,wBAAsB,aAAa,CAC/B,SAAS,GAAE,wBAAwB,GAAG,IAAW,EACjD,MAAM,GAAE,QAAQ,GAAG,OAAiB,GACrC,OAAO,CAAC,uBAAuB,CAAC,CAyBlC"}
+{"version":3,"file":"getUserConfig.d.ts","sourceRoot":"","sources":["../src/getUserConfig.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAOxF,wBAAsB,aAAa,CAC/B,SAAS,GAAE,wBAAwB,GAAG,IAAW,EACjD,MAAM,GAAE,QAAQ,GAAG,OAAiB,GACrC,OAAO,CAAC,uBAAuB,CAAC,CAsBlC"}

package/dist/getUserConfig.js

@@ -1,21 +1,21 @@
-import { ArkErrors } from 'arktype';
 import { defaultConfig } from "./defaultConfig.js";
 import { findUserConfig } from "./findUserConfig.js";
 import { frameworkConfigValidator } from "./frameworkConfigSchema.js";
 import { makeFinalConfig } from "./makeFinalConfig.js";
 import { throwError } from "./throwError.js";
 import { cliOut } from "./cliOutput.js";
+import { validate } from "./standardSchema.js";
 export async function getUserConfig(overrides = null, volume = 'noisy') {
   const userConfigOrNull = await findUserConfig(process.cwd(), volume);
   //frameworkCon
   if (userConfigOrNull !== null) {
     const userConfig = userConfigOrNull;
-    const result = frameworkConfigValidator(userConfig.data);
-    if (result instanceof ArkErrors) {
+    const result = await validate(frameworkConfigValidator, userConfig.data);
+    if (!result.success) {
       cliOut('Config', userConfig);
-      throwError('Your tungsten config did not match the required format', JSON.stringify(result.flatProblemsByPath));
+      throwError('Your tungsten config did not match the required format', '\n' + result.problems);
     }
-    const finalConfig = makeFinalConfig(result, overrides);
+    const finalConfig = makeFinalConfig(result.value, overrides);
     //console.log('finalConfig', finalConfig)
     return finalConfig;
     //return makeFinalConfig(userConfig.data)

package/dist/moduleReloader.d.ts

@@ -1,4 +1,2 @@
-export { resolve };
-import type { ResolveHook } from 'node:module';
-declare const resolve: ResolveHook;
+export {};
 //# sourceMappingURL=moduleReloader.d.ts.map

package/dist/moduleReloader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moduleReloader.d.ts","sourceRoot":"","sources":["../src/moduleReloader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAC,CAAA;AAGhB,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAA;AA2B5C,QAAA,MAAM,OAAO,EAAE,WAmCd,CAAA"}
+{"version":3,"file":"moduleReloader.d.ts","sourceRoot":"","sources":["../src/moduleReloader.ts"],"names":[],"mappings":""}

package/dist/moduleReloader.js

@@ -1,9 +1,5 @@
-export { resolve };
-import { register, isBuiltin } from 'node:module';
-if (!import.meta.url.endsWith('?loader')) {
-  register(`${import.meta.url}?loader`);
-}
-const selfURL = import.meta.url.replace(/\?loader$/, '');
+import { registerHooks, isBuiltin } from 'node:module';
+const selfURL = import.meta.url;
 const isSelf = url => url === selfURL;
 const hasUrlScheme = specifier => /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(specifier);
 const isBareImport = specifier => !specifier.startsWith('.') && !specifier.startsWith('/') && !specifier.startsWith('\\') && !hasUrlScheme(specifier);
@@ -11,21 +7,24 @@ const cachedModulePattern = /\._cached_\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/i;
 function isCachedModule(url) {
   return cachedModulePattern.test(url.pathname);
 }
-const isStaticModule = url => {
-  const pathname = url.pathname.toLowerCase();
-  return pathname.includes('/node_modules/') || pathname.includes('/.packages/');
+// takes the raw url rather than a parsed one, so the check can run before any URL is constructed
+const isStaticUrl = url => {
+  const lower = url.toLowerCase();
+  return lower.includes('/node_modules/') || lower.includes('/.packages/');
 };
 let id = 0;
-const resolve = async (specifier, context, nextResolve) => {
-  const result = await nextResolve(specifier, context);
+// registerHooks (sync, in-thread) rather than register (a separate hooks thread): the thread costs
+// ~0.54ms per resolution against ~0.02ms here, which over a dev startup's module count is ~800ms
+const resolve = (specifier, context, nextResolve) => {
+  const result = nextResolve(specifier, context);
   if (!isSelf(result.url) && !isBuiltin(result.url) && context.parentURL !== undefined) {
+    // string tests before parsing: registerHooks also sees CJS require, where register did not,
+    // and a package's own relative requires are the bulk of those - none can need tagging
+    if (isBareImport(specifier) || isStaticUrl(result.url)) return result;
     const url = new URL(result.url);
     // A *._cached_.js/ts module and its dependency graph use Node's ordinary
     // process-wide module cache instead of inheriting the test file instance.
     if (isCachedModule(url)) return result;
-    if (isBareImport(specifier) || isStaticModule(url)) {
-      return result;
-    }
     const parentUrl = new URL(context.parentURL);
     const instance = url.searchParams.get('t-reload') === '' ? `esm-reload-${id++}` : parentUrl.searchParams.get('t-instance');
     if (instance !== null) {
@@ -40,4 +39,7 @@ const resolve = async (specifier, context, nextResolve) => {
     }
   }
   return result;
-};
+};
+registerHooks({
+  resolve
+});

package/dist/standardSchema.d.ts

@@ -0,0 +1,37 @@
+export type StandardSchemaPathSegment = {
+    readonly key: PropertyKey;
+};
+export type StandardSchemaIssue = {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | StandardSchemaPathSegment)[] | undefined;
+};
+export type StandardSchemaResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardSchemaIssue[];
+};
+export type StandardSchema<Output> = {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: unknown;
+            readonly output: Output;
+        } | undefined;
+    };
+};
+type Validation<Output> = {
+    success: true;
+    value: Output;
+} | {
+    success: false;
+    problems: string;
+};
+export declare function validate<Output>(schema: StandardSchema<Output>, value: unknown): Promise<Validation<Output>>;
+export declare function formatIssues(issues: readonly StandardSchemaIssue[]): string;
+export declare function checkIsObject(location: string, name: string, value: unknown): void;
+export declare function checkIsStandardSchema(location: string, name: string, schema: unknown): void;
+export {};
+//# sourceMappingURL=standardSchema.d.ts.map

package/dist/standardSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardSchema.d.ts","sourceRoot":"","sources":["../src/standardSchema.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,yBAAyB,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;CAAE,CAAA;AAErE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,WAAW,GAAG,yBAAyB,CAAC,EAAE,GAAG,SAAS,CAAA;CACnF,CAAA;AAED,MAAM,MAAM,oBAAoB,CAAC,MAAM,IACnC;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAAE,CAAA;AAEzD,MAAM,MAAM,cAAc,CAAC,MAAM,IAAI;IACjC,QAAQ,CAAC,WAAW,EAAE;QAClB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;QACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,QAAQ,EACjB,CAAC,KAAK,EAAE,OAAO,KAAK,oBAAoB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAA;QACxF,QAAQ,CAAC,KAAK,CAAC,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;YAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;SAAE,GAAG,SAAS,CAAA;KACpF,CAAA;CACJ,CAAA;AAED,KAAK,UAAU,CAAC,MAAM,IAAI;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAGjG,wBAAsB,QAAQ,CAAC,MAAM,EACjC,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAC/C,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAI7B;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,CAE3E;AAWD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAKlF;AAGD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAgB3F"}

package/dist/standardSchema.js

@@ -0,0 +1,47 @@
+// Standard Schema v1 (https://standardschema.dev), inlined rather than taken from
+// @standard-schema/spec so nothing new lands in tungsten's shipped types. Only the output type is
+// parameterised - the input is always unknown, whether it is process.env or a user's config file.
+import { throwError } from "./throwError.js";
+// safeParse-shaped, but awaited: the spec lets a schema validate asynchronously
+export async function validate(schema, value) {
+  const result = await schema['~standard'].validate(value);
+  if (result.issues !== undefined) return {
+    success: false,
+    problems: formatIssues(result.issues)
+  };
+  return {
+    success: true,
+    value: result.value
+  };
+}
+export function formatIssues(issues) {
+  return issues.map(issue => `  ${pathOf(issue)}: ${issue.message}`).join('\n');
+}
+// a segment is either the key itself or an object wrapping it - both spellings are in the spec
+function pathOf(issue) {
+  const segments = issue.path?.map(segment => String(typeof segment === 'object' ? segment.key : segment)) ?? [];
+  return segments.length === 0 ? '(whole value)' : segments.join('.');
+}
+// Standard Schema exposes nothing about a schema's structure, so "is it an object schema?" cannot
+// be asked up front the way ZodObject allowed - this asks what it actually produced instead
+export function checkIsObject(location, name, value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throwError(location, `${name} must produce an object,` + ` but it produced ${Array.isArray(value) ? 'an array' : `type '${typeof value}'`}`);
+  }
+}
+// throws rather than returning a result, for the load-time check where there is nothing to recover to
+export function checkIsStandardSchema(location, name, schema) {
+  if (schema === null || typeof schema !== 'object') {
+    throwError(location, `${name} is not a schema - found ${typeof schema}`);
+  }
+  if (!('~standard' in schema)) {
+    throwError(location, `${name} does not implement Standard Schema (https://standardschema.dev).` + ` Use a recent zod, valibot, arktype or other supporting library.`);
+  }
+  const props = schema['~standard'];
+  if (props === null || typeof props !== 'object' || !('version' in props)) {
+    throwError(location, `${name} has a malformed '~standard' property`);
+  }
+  if (props.version !== 1) {
+    throwError(location, `${name} implements Standard Schema v${String(props.version)},` + ` and tungsten supports v1`);
+  }
+}

package/dist/timeProfiler.d.ts

@@ -2,5 +2,11 @@ export type TimeProfiler = {
     timeProfile: <T>(name: string, task: () => T) => T;
     timeProfileAsync: <T>(name: string, task: () => T | Promise<T>) => Promise<T>;
 };
+export declare function isProfiling(): boolean;
+export declare function beginStartupProfiling(profiling: boolean): void;
+export declare function reportStartupPhase(name: string): void;
+export declare function tally(name: string, ms: number): void;
+export declare function addEndOfRunReport(report: () => void): void;
+export declare function reportRunTotal(name: string): void;
 export declare function createTimeProfiler(profiling?: boolean): TimeProfiler;
 //# sourceMappingURL=timeProfiler.d.ts.map

package/dist/timeProfiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeProfiler.d.ts","sourceRoot":"","sources":["../src/timeProfiler.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,YAAY,GAAG;IACvB,WAAW,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;IAClD,gBAAgB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;CAChF,CAAA;AAMD,wBAAgB,kBAAkB,CAAC,SAAS,UAAO,GAAG,YAAY,CAqBjE"}
+{"version":3,"file":"timeProfiler.d.ts","sourceRoot":"","sources":["../src/timeProfiler.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,YAAY,GAAG;IACvB,WAAW,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;IAClD,gBAAgB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;CAChF,CAAA;AA+MD,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAGD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAG9D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAKrD;AAOD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAKpD;AA0BD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAE1D;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CASjD;AAED,wBAAgB,kBAAkB,CAAC,SAAS,UAAO,GAAG,YAAY,CAoCjE"}

package/dist/timeProfiler.js

@@ -1,11 +1,239 @@
 // Same shape as sxy-test-runner's createTimeProfiler (node_modules/sxy-test-runner/dist/packages/timeProfiler.js) -
 // a disabled profiler just runs the task, so callers never need to branch on whether profiling
-// is on. Framework.ts holds one instance per run (default disabled); tungsten dev/build enable
-// it via --profile and wrap their own top-level phases with it too.
+// is on. Framework.ts holds one instance per run (default disabled); tungsten dev/build/compile
+// enable it via --profile and wrap their own top-level phases with it too.
+import { performance } from 'node:perf_hooks';
+import { AsyncLocalStorage, createHook } from 'node:async_hooks';
 import chalk from 'chalk-extensions';
 import { cliOut } from "./cliOutput.js";
-function report(name, ms) {
-  cliOut(chalk.yellow`${name}` + ' - ' + chalk.orange`${ms.toLocaleString()}ms`);
+// Nesting has to be recorded, not inferred: sibling phases started together sit inside each other's
+// time windows, so intervals alone cannot tell a nested call from a concurrent one. Async storage
+// gives each task its own phase even when several run at once.
+const currentPhase = new AsyncLocalStorage();
+const framesInFlight = [];
+const resourceOwner = new Map();
+let accounting = false;
+// Attributes each async callback's synchronous run to the phase that created the resource. Only
+// under --profile: the hooks fire on every async operation and are not free.
+function startCpuAccounting() {
+  if (accounting) return;
+  accounting = true;
+  createHook({
+    init(asyncId, kind) {
+      const phase = currentPhase.getStore();
+      if (phase === undefined) return;
+      resourceOwner.set(asyncId, {
+        phase,
+        created: performance.now(),
+        kind
+      });
+    },
+    before(asyncId) {
+      const owner = resourceOwner.get(asyncId);
+      if (owner === undefined) return;
+      const now = performance.now();
+      const wait = owner.phase.waits.get(owner.kind) ?? {
+        ms: 0,
+        count: 0
+      };
+      wait.ms += now - owner.created;
+      wait.count++;
+      owner.phase.waits.set(owner.kind, wait);
+      framesInFlight.push({
+        phase: owner.phase,
+        start: now,
+        childCpu: 0
+      });
+    },
+    after(asyncId) {
+      if (!resourceOwner.has(asyncId)) return;
+      const frame = framesInFlight.pop();
+      if (frame === undefined) return;
+      const total = performance.now() - frame.start;
+      const own = total - frame.childCpu;
+      frame.phase.cpu += own;
+      // deferred work: started here, ran after this phase returned
+      if (frame.phase.finished) frame.phase.cpuAfterEnd += own;
+      const parent = framesInFlight[framesInFlight.length - 1];
+      if (parent !== undefined) parent.childCpu += total;
+    },
+    destroy(asyncId) {
+      resourceOwner.delete(asyncId);
+    }
+  }).enable();
+}
+// Every phase reported in the run. performance.now() is process-relative, so startup phases and
+// each profiler's phases share one timeline - which is what makes the overlaps legible: several
+// of these phases run concurrently (the compile targets, and the wrappers around them), so their
+// durations deliberately do not sum to the total.
+const phases = [];
+function ms(value) {
+  return `${Math.round(value).toLocaleString()}ms`;
+}
+// Created when the phase starts, so async resources made inside it can be charged to it while it
+// runs; end is filled in by finishPhase().
+function startPhase(name, start, parent) {
+  const phase = {
+    name,
+    start,
+    end: start,
+    depth: parent === undefined ? 0 : parent.depth + 1,
+    cpu: 0,
+    childSyncCpu: 0,
+    cpuAfterEnd: 0,
+    finished: false,
+    parent,
+    waits: new Map()
+  };
+  phases.push(phase);
+  return phase;
+}
+function finishPhase(phase, end) {
+  phase.end = end;
+  phase.finished = true;
+  cliOut(chalk.yellow`${phase.name}` + ' - ' + chalk.orange`${ms(end - phase.start)}`
+  // the window, not just the duration: concurrent phases share one, and a flat list of
+  // durations reads as if they ran one after another
+  + chalk.mediumgrey` (${Math.round(phase.start).toLocaleString()} - ${ms(end)})`);
+}
+// The startup phases - node's boot and the command's module evaluation. They run before any phase
+// context exists, so the hooks never see them; nothing else is on the loop then either, which makes
+// their elapsed time their cpu time and keeps the cpu column summing to the run total.
+function report(name, start, end) {
+  const phase = startPhase(name, start, undefined);
+  phase.cpu = end - start;
+  finishPhase(phase, end);
+}
+// A bar alone could not say whether two phases nest or run alongside each other, and at any width a
+// cell is worth enough milliseconds that short phases get padded and then misreport their duration.
+// So the structure is carried by indentation and the "with" note, and the bar only shows placement -
+// drawn thin where it is padding rather than duration, so it cannot be read as a real span.
+function reportTimeline() {
+  if (phases.length === 0) return;
+  // depth first from the roots, each level in start order - a flat sort by start puts a phase
+  // under whatever happened to run before it, which reads as the wrong parent
+  const childrenOf = new Map();
+  for (const phase of phases) {
+    const siblings = childrenOf.get(phase.parent) ?? [];
+    siblings.push(phase);
+    childrenOf.set(phase.parent, siblings);
+  }
+  const ordered = [];
+  const addBranch = phase => {
+    ordered.push(phase);
+    for (const child of [...(childrenOf.get(phase) ?? [])].sort((a, b) => a.start - b.start)) {
+      addBranch(child);
+    }
+  };
+  for (const root of [...(childrenOf.get(undefined) ?? [])].sort((a, b) => a.start - b.start)) {
+    addBranch(root);
+  }
+  const labelWidth = Math.max(...ordered.map(phase => phase.name.length + phase.depth * 2));
+  const total = Math.max(...ordered.map(phase => phase.end));
+  // the terminal's width, less the label, the duration and room for the notes after the bar.
+  // columns is typed as a number but is undefined when stdout is not a tty, hence Number()
+  const columns = Number(process.stdout.columns) || 100;
+  const barWidth = Math.max(20, Math.min(90, columns - labelWidth - 34));
+  // everything before the notes: indent, label, elapsed, cpu, their separators, and the bar
+  const rowWidth = 2 + labelWidth + 1 + 9 + 1 + 13 + 1 + barWidth;
+  cliOut('');
+  cliOut(chalk.mediumgrey`phases - indented by nesting. elapsed is wall clock and overlaps; cpu is` + chalk.mediumgrey` work started by this phase, wherever it ran, and sums to the run total`);
+  for (const phase of ordered) {
+    // cpu is charged to the phase that created the work, so this is already exclusive of child
+    // phases once their synchronous starts are removed - unlike elapsed, these figures do sum
+    const ownCpu = phase.cpu - phase.childSyncCpu;
+    const from = Math.min(Math.round(phase.start / total * barWidth), barWidth - 1);
+    const to = Math.min(Math.max(Math.round(phase.end / total * barWidth), from + 1), barWidth);
+    const glyph = (phase.end - phase.start) / total * barWidth < 1 ? '▏' : '█';
+    const label = '  '.repeat(phase.depth) + phase.name;
+    // Solid for the phase's own cpu, hollow for the rest of its span - a phase that is mostly
+    // hollow was mostly waiting on the thread rather than using it. A proportion, not a
+    // position: the cpu is interleaved across the span, not spent at the front of it.
+    const cells = to - from;
+    const workCells = Math.min(cells, Math.max(ownCpu > 0 ? 1 : 0, Math.round(ownCpu / total * barWidth)));
+    const bar = glyph === '▏' ? glyph : chalk.orange`${'█'.repeat(workCells)}` + chalk.mediumgrey`${'░'.repeat(cells - workCells)}`;
+    // Work is charged to the phase that created the resource, wherever it later runs, so a
+    // phase that queues work for something else to await can report more cpu than it existed
+    // for - the excess ran after it returned, and whatever awaited it will read as ~0.
+    // the kind of async work the phase spent longest waiting on, named as node names it
+    const [waitedOn] = [...phase.waits].sort((a, b) => b[1].ms - a[1].ms);
+    const fullNotes = (phase.cpuAfterEnd > 1 ? ` ${ms(phase.cpuAfterEnd)} of it deferred` : '') + (waitedOn !== undefined && waitedOn[1].ms > 1 ? ` waits ${waitedOn[0]} x${waitedOn[1].count}` : '');
+    // trimmed to what is left of the line - a wrapped note breaks the column alignment of
+    // every row after it, which is worse than losing the end of one label
+    const notes = fullNotes.slice(0, Math.max(0, columns - rowWidth - 1));
+    cliOut('  ' + chalk.yellow`${label.padEnd(labelWidth)}` + ' ' + chalk.orange`${ms(phase.end - phase.start).padStart(9)}` + ' ' + chalk.mediumgrey`${`cpu ${ms(ownCpu)}`.padStart(13)}` + ' ' + ' '.repeat(from) + bar
+    // only pad out to the full bar when something follows it
+    + (notes === '' ? '' : ' '.repeat(barWidth - to) + chalk.mediumgrey`${notes}`));
+  }
+}
+// Phases no Framework profiler can see: node's own boot, then evaluating the import tree of the
+// command module bin/index.ts dynamically imports. performance.now() counts from process start,
+// so the first phase reported measures from there; state is module-level because index.ts starts
+// the timing and the command module it imports finishes it.
+let startupProfiling = false;
+let lastPhaseEnd = 0;
+// Whether --profile is on, for the instrumentation deeper in the build to consult directly. A
+// global rather than a threaded parameter: profiling is a diagnostic, and carrying its switches
+// through every signature between the CLI and a babel visitor would touch code that never uses them.
+export function isProfiling() {
+  return startupProfiling;
+}
+// call from the CLI entry once the command is known
+export function beginStartupProfiling(profiling) {
+  startupProfiling = profiling;
+  reportStartupPhase('node boot + cli entry');
+}
+export function reportStartupPhase(name) {
+  if (!startupProfiling) return;
+  const now = performance.now();
+  report(name, lastPhaseEnd, now);
+  lastPhaseEnd = now;
+}
+// Per-operation totals, for pricing one call inside a phase - a phase says where time went, this
+// says what it went on. Accumulating is two clock reads, so callers need not check whether
+// profiling is on; only the report is gated.
+const tallies = new Map();
+export function tally(name, ms) {
+  const entry = tallies.get(name) ?? {
+    calls: 0,
+    ms: 0
+  };
+  entry.calls++;
+  entry.ms += ms;
+  tallies.set(name, entry);
+}
+// Deliberately no async variant. Concurrent operations overlap, so summing their wall clock counts
+// the same time once per operation - 291 parallel transforms tallied as 689,576ms of an 11s run.
+// Time async work with a phase, whose cpu figure is attributed rather than summed.
+function reportTallies() {
+  if (tallies.size === 0) return;
+  cliOut('');
+  cliOut(chalk.mediumgrey`tallied work - synchronous totals across the run, nested counted in both`);
+  const nameWidth = Math.max(...[...tallies.keys()].map(name => name.length));
+  for (const [name, {
+    calls,
+    ms: total
+  }] of [...tallies].sort((a, b) => b[1].ms - a[1].ms)) {
+    cliOut('  ' + chalk.yellow`${name.padEnd(nameWidth)}` + ' ' + chalk.orange`${ms(total).padStart(10)}` + ' ' + chalk.mediumgrey`${`${calls.toLocaleString()} calls`.padStart(13)}` + ' ' + chalk.mediumgrey`${`${(total / calls).toFixed(2)}ms each`}`);
+  }
+}
+// Other reports to print where the run total goes - the module load analysis registers itself here.
+// It cannot wait for process exit: dev and compile --watch keep running and are killed by a signal,
+// which skips exit handlers entirely.
+const endOfRunReports = [];
+export function addEndOfRunReport(report) {
+  endOfRunReports.push(report);
+}
+// wall clock for the whole command, node boot and module loading included
+export function reportRunTotal(name) {
+  const total = performance.now();
+  // --profile-modules works on its own, so the extra reports are not gated on --profile
+  if (startupProfiling) {
+    reportTimeline();
+    reportTallies();
+    cliOut(chalk.yellow`${name}` + ' - ' + chalk.orange`${ms(total)}`);
+  }
+  for (const report of endOfRunReports) report();
 }
 export function createTimeProfiler(profiling = true) {
   if (!profiling) {
@@ -14,17 +242,32 @@ export function createTimeProfiler(profiling = true) {
       timeProfileAsync: async (_name, task) => task()
     };
   }
+  startCpuAccounting();
   return {
     timeProfile(name, task) {
-      const start = Date.now();
-      const result = task();
-      report(name, Date.now() - start);
+      const parent = currentPhase.getStore();
+      const start = performance.now();
+      const phase = startPhase(name, start, parent);
+      const result = currentPhase.run(phase, task);
+      const end = performance.now();
+      // wholly synchronous, so none of it crosses an async callback for the hooks to charge
+      phase.cpu += end - start;
+      if (parent !== undefined) parent.childSyncCpu += end - start;
+      finishPhase(phase, end);
       return result;
     },
     async timeProfileAsync(name, task) {
-      const start = Date.now();
-      const result = await task();
-      report(name, Date.now() - start);
+      const parent = currentPhase.getStore();
+      const start = performance.now();
+      const phase = startPhase(name, start, parent);
+      // the task runs synchronously up to its first await, and that stretch belongs to this
+      // phase too - the hooks only see work that arrives through an async callback
+      const pending = currentPhase.run(phase, task);
+      const prefix = performance.now() - start;
+      phase.cpu += prefix;
+      if (parent !== undefined) parent.childSyncCpu += prefix;
+      const result = await pending;
+      finishPhase(phase, performance.now());
       return result;
     }
   };