@simulatte/doppler 0.1.4 → 0.1.6

package/src/tooling/conversion-config-materializer.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+
+import { createConverterConfig } from '../config/schema/index.js';
+import { resolveConversionPlan } from '../converter/conversion-plan.js';
+
+function toSafeString(value) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  return trimmed || '';
+}
+
+function normalizeQuantizationTag(value) {
+  const raw = toSafeString(value).toUpperCase();
+  if (!raw) return 'f16';
+  if (raw === 'Q4_K_M' || raw === 'Q4_K') return 'q4k';
+  return raw.toLowerCase();
+}
+
+function resolveArchitectureHint(architecture) {
+  if (!architecture) return '';
+  if (typeof architecture === 'string') return architecture;
+  return (
+    toSafeString(architecture.id)
+    || toSafeString(architecture.name)
+    || toSafeString(architecture.type)
+    || ''
+  );
+}
+
+function resolveHeadDim(architecture) {
+  const headDim = Number(architecture?.headDim ?? architecture?.head_dim);
+  return Number.isFinite(headDim) && headDim > 0 ? headDim : null;
+}
+
+function extractSourceQuantization(manifest) {
+  const explicitWeights = toSafeString(manifest?.quantizationInfo?.weights);
+  if (explicitWeights) return explicitWeights;
+  const explicitQuant = toSafeString(manifest?.quantization);
+  if (explicitQuant) return explicitQuant;
+  return 'f16';
+}
+
+function buildRefreshRawConfig(manifest) {
+  const baseConfig = (manifest?.config && typeof manifest.config === 'object')
+    ? { ...manifest.config }
+    : {};
+  const manifestLayerTypes = manifest?.inference?.layerPattern?.layerTypes;
+  if (Array.isArray(manifestLayerTypes) && manifestLayerTypes.length > 0) {
+    return {
+      ...baseConfig,
+      layer_types: [...manifestLayerTypes],
+    };
+  }
+  return baseConfig;
+}
+
+export function extractTensorEntriesFromManifest(manifest) {
+  if (!(manifest?.tensors && typeof manifest.tensors === 'object' && !Array.isArray(manifest.tensors))) {
+    return [];
+  }
+  return Object.entries(manifest.tensors).map(([name, tensor]) => ({
+    name,
+    dtype: tensor?.dtype ?? null,
+    shape: tensor?.shape ?? null,
+    role: tensor?.role ?? null,
+    layout: tensor?.layout ?? null,
+  }));
+}
+
+export function resolveMaterializedManifestFromConversionConfig(conversionConfigInput, manifest) {
+  const converterConfig = createConverterConfig(conversionConfigInput);
+  const tensorEntries = extractTensorEntriesFromManifest(manifest);
+  const architecture = manifest?.architecture && typeof manifest.architecture === 'object'
+    ? manifest.architecture
+    : null;
+  const plan = resolveConversionPlan({
+    rawConfig: buildRefreshRawConfig(manifest),
+    tensors: tensorEntries,
+    converterConfig,
+    sourceQuantization: normalizeQuantizationTag(extractSourceQuantization(manifest)),
+    modelKind: manifest?.modelType === 'diffusion' ? 'diffusion' : 'transformer',
+    architectureHint: resolveArchitectureHint(manifest?.architecture),
+    architectureConfig: architecture,
+    headDim: resolveHeadDim(architecture),
+    presetOverride: converterConfig?.presets?.model || manifest?.inference?.presetId || null,
+  });
+  return {
+    modelId: manifest?.modelId ?? converterConfig?.output?.modelBaseId ?? 'unknown',
+    modelType: manifest?.modelType ?? plan?.modelType ?? 'transformer',
+    architecture: manifest?.architecture ?? null,
+    inference: plan?.manifestInference ?? null,
+  };
+}
+
+export function inferConversionConfigModelId(configPath, conversionConfigInput) {
+  const configuredId = toSafeString(conversionConfigInput?.output?.modelBaseId);
+  if (configuredId) return configuredId;
+  return path.basename(String(configPath), path.extname(String(configPath)));
+}

package/src/tooling/lean-execution-contract-runner.d.ts

@@ -0,0 +1,43 @@
+export interface LeanExecutionContractRunResult {
+  ok: boolean;
+  toolchainRef: string | null;
+  generatedPath: string;
+  moduleName: string;
+  facts: Record<string, unknown>;
+}
+
+export declare function resolveLeanBinary(): string;
+
+export declare function runLeanCheck(options: {
+  sourcePath: string;
+  rootDir: string;
+}): {
+  ok: boolean;
+  toolchainRef: string;
+};
+
+export declare function writeExecutionContractLeanModuleForManifest(
+  manifest: Record<string, unknown>,
+  options?: {
+    rootDir?: string;
+    moduleName?: string;
+    emitPath?: string | null;
+  }
+): {
+  rootDir: string;
+  facts: Record<string, unknown>;
+  moduleName: string;
+  source: string;
+  generatedPath: string;
+  tempDir: string | null;
+};
+
+export declare function runLeanExecutionContractForManifest(
+  manifest: Record<string, unknown>,
+  options?: {
+    rootDir?: string;
+    moduleName?: string;
+    emitPath?: string | null;
+    check?: boolean;
+  }
+): LeanExecutionContractRunResult;

package/src/tooling/lean-execution-contract-runner.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import {
+  extractExecutionContractFacts,
+  renderExecutionContractLeanModule,
+  sanitizeLeanModuleName,
+} from './lean-execution-contract.js';
+
+export function resolveLeanBinary() {
+  const elanLean = path.join(os.homedir(), '.elan', 'bin', 'lean');
+  if (fs.existsSync(elanLean)) {
+    return elanLean;
+  }
+  const probe = spawnSync('bash', ['-lc', 'command -v lean'], { encoding: 'utf8' });
+  if (probe.status === 0) {
+    const resolved = probe.stdout.trim();
+    if (resolved) {
+      return resolved;
+    }
+  }
+  throw new Error('lean binary not found. Install Lean with elan first.');
+}
+
+function runLeanCommand({ leanBin, toolchainRef, buildDir, rootDir, sourcePath, outputPath }) {
+  const result = spawnSync(
+    leanBin,
+    [`+${toolchainRef}`, '-o', outputPath, sourcePath],
+    {
+      cwd: rootDir,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        LEAN_PATH: `${buildDir}:${path.join(rootDir, 'lean')}`,
+      },
+    }
+  );
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  if (result.status !== 0) {
+    throw new Error(`lean exited with status ${result.status}`);
+  }
+}
+
+export function runLeanCheck({ sourcePath, rootDir }) {
+  const toolchainVersion = process.env.DOPPLER_LEAN_VERSION ?? '4.16.0';
+  const toolchainRef = toolchainVersion.startsWith('v')
+    ? `leanprover/lean4:${toolchainVersion}`
+    : `leanprover/lean4:v${toolchainVersion}`;
+  const leanBin = resolveLeanBinary();
+  const buildDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doppler-lean-execution-contract-'));
+  try {
+    fs.mkdirSync(path.join(buildDir, 'Doppler'), { recursive: true });
+    runLeanCommand({
+      leanBin,
+      toolchainRef,
+      buildDir,
+      rootDir,
+      sourcePath: path.join(rootDir, 'lean', 'Doppler', 'Model.lean'),
+      outputPath: path.join(buildDir, 'Doppler', 'Model.olean'),
+    });
+    runLeanCommand({
+      leanBin,
+      toolchainRef,
+      buildDir,
+      rootDir,
+      sourcePath: path.join(rootDir, 'lean', 'Doppler', 'ExecutionContract.lean'),
+      outputPath: path.join(buildDir, 'Doppler', 'ExecutionContract.olean'),
+    });
+    const generatedOutput = path.join(buildDir, 'GeneratedExecutionContractCheck.olean');
+    const result = spawnSync(
+      leanBin,
+      [`+${toolchainRef}`, '-o', generatedOutput, sourcePath],
+      {
+        cwd: rootDir,
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          LEAN_PATH: `${buildDir}:${path.join(rootDir, 'lean')}`,
+        },
+      }
+    );
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+    }
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+    }
+    if (result.status !== 0) {
+      throw new Error(`lean exited with status ${result.status}`);
+    }
+    const overallMatch = result.stdout.match(/executionContractOverall:(pass|fail)/);
+    if (!overallMatch) {
+      throw new Error('unable to parse executionContractOverall from Lean output.');
+    }
+    return { ok: overallMatch[1] === 'pass', toolchainRef };
+  } finally {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+  }
+}
+
+export function writeExecutionContractLeanModuleForManifest(manifest, options = {}) {
+  const rootDir = path.resolve(String(options.rootDir ?? process.cwd()));
+  const facts = extractExecutionContractFacts(manifest);
+  const moduleName = sanitizeLeanModuleName(options.moduleName ?? `${facts.modelId}_ExecutionContractCheck`);
+  const source = renderExecutionContractLeanModule(facts, { moduleName });
+  const tempDir = options.emitPath
+    ? null
+    : fs.mkdtempSync(path.join(rootDir, 'lean', '.generated-'));
+  const generatedPath = options.emitPath
+    ? path.resolve(rootDir, String(options.emitPath))
+    : path.join(tempDir, `${moduleName}.lean`);
+  fs.mkdirSync(path.dirname(generatedPath), { recursive: true });
+  fs.writeFileSync(generatedPath, source);
+  return {
+    rootDir,
+    facts,
+    moduleName,
+    source,
+    generatedPath,
+    tempDir,
+  };
+}
+
+export function runLeanExecutionContractForManifest(manifest, options = {}) {
+  const generated = writeExecutionContractLeanModuleForManifest(manifest, options);
+  try {
+    if (options.check === false) {
+      return {
+        ok: true,
+        toolchainRef: null,
+        generatedPath: generated.generatedPath,
+        moduleName: generated.moduleName,
+        facts: generated.facts,
+      };
+    }
+    const result = runLeanCheck({
+      sourcePath: generated.generatedPath,
+      rootDir: generated.rootDir,
+    });
+    return {
+      ...result,
+      generatedPath: generated.generatedPath,
+      moduleName: generated.moduleName,
+      facts: generated.facts,
+    };
+  } finally {
+    if (!options.emitPath && generated.tempDir) {
+      fs.rmSync(generated.tempDir, { recursive: true, force: true });
+    }
+  }
+}

package/src/tooling/node-browser-command-runner.d.ts

@@ -7,6 +7,10 @@ import type { BrowserCommandRunResult } from './browser-command-runner.js';
 
 export interface NodeBrowserCommandRunOptions {
   staticRootDir?: string;
+  staticMounts?: Array<{
+    urlPrefix: string;
+    rootDir: string;
+  }>;
   baseUrl?: string;
   host?: string;
   port?: number;

package/src/tooling/node-browser-command-runner.js

@@ -67,8 +67,61 @@ function resolveStaticPath(rootDir, requestPath) {
   return candidate;
 }
 
-async function resolveFileForRequest(rootDir, requestPath) {
-  const resolved = resolveStaticPath(rootDir, requestPath);
+function normalizeStaticMounts(mounts = []) {
+  if (!Array.isArray(mounts)) {
+    throw new Error('browser command: staticMounts must be an array.');
+  }
+
+  return mounts.map((mount, index) => {
+    if (!mount || typeof mount !== 'object' || Array.isArray(mount)) {
+      throw new Error(`browser command: staticMounts[${index}] must be an object.`);
+    }
+    const urlPrefix = String(mount.urlPrefix || '').trim();
+    const rootDir = String(mount.rootDir || '').trim();
+    if (!urlPrefix.startsWith('/')) {
+      throw new Error(`browser command: staticMounts[${index}].urlPrefix must start with "/".`);
+    }
+    if (!rootDir) {
+      throw new Error(`browser command: staticMounts[${index}].rootDir is required.`);
+    }
+    return {
+      urlPrefix: urlPrefix.replace(/\/+$/u, '') || '/',
+      rootDir: path.resolve(rootDir),
+    };
+  });
+}
+
+function findStaticRootForRequest(rootDir, mounts, requestPath) {
+  const normalizedPath = String(requestPath || '/');
+  let bestMount = null;
+
+  for (const mount of mounts) {
+    const prefix = mount.urlPrefix;
+    if (normalizedPath !== prefix && !normalizedPath.startsWith(`${prefix}/`)) {
+      continue;
+    }
+    if (!bestMount || prefix.length > bestMount.urlPrefix.length) {
+      bestMount = mount;
+    }
+  }
+
+  if (!bestMount) {
+    return {
+      effectiveRootDir: rootDir,
+      effectivePath: normalizedPath,
+    };
+  }
+
+  const relativePath = normalizedPath.slice(bestMount.urlPrefix.length) || '/';
+  return {
+    effectiveRootDir: bestMount.rootDir,
+    effectivePath: relativePath.startsWith('/') ? relativePath : `/${relativePath}`,
+  };
+}
+
+async function resolveFileForRequest(rootDir, mounts, requestPath) {
+  const { effectiveRootDir, effectivePath } = findStaticRootForRequest(rootDir, mounts, requestPath);
+  const resolved = resolveStaticPath(effectiveRootDir, effectivePath);
   if (!resolved) return null;
 
   let stats;
@@ -99,6 +152,7 @@ async function createStaticFileServer(options = {}) {
   const rootDir = path.resolve(
     options.rootDir || fileURLToPath(new URL('../../', import.meta.url))
   );
+  const staticMounts = normalizeStaticMounts(options.staticMounts || []);
   const host = String(options.host || DEFAULT_HOST);
   const port = Number.isFinite(options.port) ? Math.max(0, Math.floor(options.port)) : 0;
 
@@ -120,7 +174,7 @@ async function createStaticFileServer(options = {}) {
       return;
     }
 
-    const resolved = await resolveFileForRequest(rootDir, pathname);
+    const resolved = await resolveFileForRequest(rootDir, staticMounts, pathname);
     if (!resolved) {
       res.statusCode = 404;
       res.end('File not found');
@@ -545,6 +599,7 @@ export async function runBrowserCommandInNode(commandRequest, options = {}) {
     ? null
     : await createStaticFileServer({
       rootDir: options.staticRootDir,
+      staticMounts: options.staticMounts,
       host: options.host,
       port: serverPort,
     }).catch((error) => {

package/src/tooling/node-command-runner.js

@@ -18,6 +18,7 @@ import {
   getActiveKernelPathSource,
   setActiveKernelPath,
 } from '../config/kernel-path-loader.js';
+import { runTrainingOperatorCommand } from '../training/operator-command.js';
 
 function asOptionalPlainObject(value, label) {
   if (value == null) return null;
@@ -90,6 +91,20 @@ export async function runNodeCommand(commandRequest, options = {}) {
       });
     }
 
+    if (request.command === 'lora' || request.command === 'distill') {
+      const gpuOptionalActions = new Set(['compare', 'quality-gate', 'subsets']);
+      installNodeFileFetchShim();
+      if (!gpuOptionalActions.has(request.action)) {
+        await assertNodeWebGPUSupport();
+      }
+      const result = await runTrainingOperatorCommand(request);
+      return createToolingSuccessEnvelope({
+        surface: 'node',
+        request,
+        result,
+      });
+    }
+
     await assertNodeWebGPUSupport();
     const modules = await loadRuntimeModules();
     const runtimeBridge = {

package/src/tooling/node-convert.d.ts

@@ -1,4 +1,8 @@
 import type { ConverterConfigSchema } from '../config/schema/converter.schema.js';
+import type { ExecutionContractArtifact } from '../config/execution-contract-check.js';
+import type { ExecutionV0GraphContractArtifact } from '../config/execution-v0-graph-contract-check.js';
+import type { ManifestRequiredInferenceFieldsArtifact } from '../config/required-inference-fields-contract-check.js';
+import type { SavedReportInfo } from '../storage/reports.js';
 
 export interface NodeConvertProgress {
   stage: string | null;
@@ -34,6 +38,12 @@ export interface ConvertSafetensorsDirectoryResult {
   manifest: Record<string, unknown>;
   shardCount: number;
   tensorCount: number;
+  executionContractArtifact: ExecutionContractArtifact | null;
+  executionV0GraphContractArtifact: ExecutionV0GraphContractArtifact | null;
+  layerPatternContractArtifact: Record<string, unknown> | null;
+  requiredInferenceFieldsArtifact: ManifestRequiredInferenceFieldsArtifact | null;
+  report: Record<string, unknown>;
+  reportInfo: SavedReportInfo;
   presetId: string;
   modelType: string;
   outputDir: string;

package/src/tooling/node-converter.js

@@ -7,6 +7,11 @@ import { bootstrapNodeWebGPU } from './node-webgpu.js';
 import { isPlainObject } from '../utils/plain-object.js';
 import { selectRuleValue } from '../rules/rule-registry.js';
 import { log, trace } from '../debug/index.js';
+import { saveReport } from '../storage/reports.js';
+import {
+  CONVERSION_REPORT_SCHEMA_VERSION,
+  validateConversionReport,
+} from '../config/schema/conversion-report.schema.js';
 
 function asPositiveInteger(value, label) {
   if (!Number.isInteger(value) || value < 1) {
@@ -594,6 +599,44 @@ function normalizeTokenizerManifest(manifest) {
   return manifest;
 }
 
+function buildConvertReport(result, context) {
+  const manifest = result?.manifest ?? null;
+  const inference = manifest?.inference && typeof manifest.inference === 'object'
+    ? manifest.inference
+    : null;
+  return validateConversionReport({
+    schemaVersion: CONVERSION_REPORT_SCHEMA_VERSION,
+    suite: 'convert',
+    command: 'convert',
+    modelId: manifest?.modelId ?? context.modelId ?? 'unknown',
+    timestamp: manifest?.metadata?.convertedAt ?? new Date().toISOString(),
+    source: 'doppler',
+    result: {
+      presetId: context.presetId ?? null,
+      modelType: context.modelType ?? null,
+      outputDir: context.outputDir ?? null,
+      shardCount: result?.shardCount ?? null,
+      tensorCount: result?.tensorCount ?? null,
+      totalSize: result?.totalSize ?? null,
+    },
+    manifest: manifest
+      ? {
+          quantization: manifest.quantization ?? null,
+          quantizationInfo: manifest.quantizationInfo ?? null,
+          inference: {
+            presetId: inference?.presetId ?? null,
+            schema: inference?.schema ?? null,
+            defaultKernelPath: inference?.defaultKernelPath ?? null,
+          },
+        }
+      : null,
+    executionContractArtifact: result?.executionContractArtifact ?? null,
+    executionV0GraphContractArtifact: result?.executionV0GraphContractArtifact ?? null,
+    layerPatternContractArtifact: result?.layerPatternContractArtifact ?? null,
+    requiredInferenceFieldsArtifact: result?.requiredInferenceFieldsArtifact ?? null,
+  });
+}
+
 function createNodeTensorTransformer(options) {
   const pool = options?.pool;
   const execution = options?.execution;
@@ -1212,10 +1255,26 @@ export async function convertSafetensorsDirectory(options) {
   normalizeTokenizerManifest(result.manifest);
   await io.writeManifest(result.manifest);
 
+  const report = buildConvertReport(result, {
+    presetId,
+    modelType: resolvedModelType,
+    outputDir,
+    modelId: result.manifest?.modelId ?? modelId,
+  });
+  const reportInfo = await saveReport(report.modelId, report, {
+    timestamp: report.timestamp,
+  });
+
   return {
     manifest: result.manifest,
     shardCount: result.shardCount,
     tensorCount: result.tensorCount,
+    executionContractArtifact: result.executionContractArtifact ?? null,
+    executionV0GraphContractArtifact: result.executionV0GraphContractArtifact ?? null,
+    layerPatternContractArtifact: result.layerPatternContractArtifact ?? null,
+    requiredInferenceFieldsArtifact: result.requiredInferenceFieldsArtifact ?? null,
+    report,
+    reportInfo,
     presetId,
     modelType: resolvedModelType,
     outputDir,

package/src/tooling/node-webgpu.js

@@ -2,17 +2,6 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
-const DOPPLER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
-
-const DEFAULT_LOCAL_DOE_PROVIDER_PATH = resolve(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  '..',
-  'fawn',
-  'nursery',
-  'webgpu-core',
-);
 const DEFAULT_DOE_PROVIDER_CREATE_ARGS = 'enable-dawn-features=allow_unsafe_apis';
 
 function hasNavigatorGpu() {
@@ -59,20 +48,7 @@ function resolveCandidateModuleSpecifier(candidate) {
 }
 
 function resolveDefaultWebgpuModuleSpecifiers() {
-  const specifiers = [];
-  const localCandidates = [
-    resolve(process.cwd(), '..', 'fawn', 'nursery', 'webgpu-core'),
-    DEFAULT_LOCAL_DOE_PROVIDER_PATH,
-  ];
-  for (const localCandidate of localCandidates) {
-    const resolvedPath = resolveNodeModuleFilePath(localCandidate);
-    if (resolvedPath) {
-      specifiers.push(pathToFileURL(resolvedPath).href);
-    }
-  }
-  specifiers.push('@doe/webgpu-core');
-  specifiers.push('webgpu');
-  return [...new Set(specifiers)];
+  return ['@simulatte/webgpu', 'webgpu'];
 }
 
 function resolveWebgpuModuleSpecifiers() {
@@ -89,80 +65,26 @@ function resolveWebgpuModuleSpecifiers() {
   };
 }
 
-function resolveWorkspaceWebgpuProviderPath() {
-  const candidates = [
-    resolve(process.cwd(), 'node_modules', 'webgpu'),
-    resolve(DOPPLER_ROOT, 'node_modules', 'webgpu'),
-  ];
-  for (const candidate of candidates) {
-    const resolvedPath = resolveNodeModuleFilePath(candidate);
-    if (resolvedPath) {
-      return resolvedPath;
-    }
-  }
-  return null;
-}
-
-function isDoeWebgpuCoreSpecifier(specifier) {
-  if (specifier === '@doe/webgpu-core') {
-    return true;
-  }
-  if (typeof specifier !== 'string') {
-    return false;
-  }
-  if (specifier.includes('/webgpu-core/')) {
+function isDoeWebgpuSpecifier(specifier) {
+  if (specifier === '@simulatte/webgpu') {
     return true;
   }
-  return specifier.includes('webgpu-core') && specifier.startsWith('file://');
-}
-
-function resolveDoeProviderOverride(specifier) {
-  const explicitProvider = process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE;
-  if (typeof explicitProvider === 'string' && explicitProvider.trim().length > 0) {
-    return null;
-  }
-  if (!isDoeWebgpuCoreSpecifier(specifier)) {
-    return null;
-  }
-  return resolveWorkspaceWebgpuProviderPath();
+  return typeof specifier === 'string'
+    && specifier.startsWith('file://')
+    && specifier.includes('@simulatte/webgpu');
 }
 
 async function importWithProviderOverride(specifier) {
-  const providerOverride = resolveDoeProviderOverride(specifier);
-  const shouldApplyCreateArgsDefault = isDoeWebgpuCoreSpecifier(specifier)
+  const shouldApplyCreateArgsDefault = isDoeWebgpuSpecifier(specifier)
     && !(typeof process.env.FAWN_WEBGPU_CREATE_ARGS === 'string' && process.env.FAWN_WEBGPU_CREATE_ARGS.trim().length > 0);
-  if (!providerOverride) {
-    if (!shouldApplyCreateArgsDefault) {
-      return import(specifier);
-    }
-    process.env.FAWN_WEBGPU_CREATE_ARGS = DEFAULT_DOE_PROVIDER_CREATE_ARGS;
-    try {
-      return await import(specifier);
-    } finally {
-      delete process.env.FAWN_WEBGPU_CREATE_ARGS;
-    }
-  }
-  const hadProvider = Object.prototype.hasOwnProperty.call(process.env, 'FAWN_WEBGPU_NODE_PROVIDER_MODULE');
-  const previousProvider = process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE;
-  const hadCreateArgs = Object.prototype.hasOwnProperty.call(process.env, 'FAWN_WEBGPU_CREATE_ARGS');
-  const previousCreateArgs = process.env.FAWN_WEBGPU_CREATE_ARGS;
-  process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE = providerOverride;
-  if (!hadCreateArgs) {
-    process.env.FAWN_WEBGPU_CREATE_ARGS = DEFAULT_DOE_PROVIDER_CREATE_ARGS;
+  if (!shouldApplyCreateArgsDefault) {
+    return import(specifier);
   }
+  process.env.FAWN_WEBGPU_CREATE_ARGS = DEFAULT_DOE_PROVIDER_CREATE_ARGS;
   try {
     return await import(specifier);
   } finally {
-    if (hadProvider) {
-      process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE = previousProvider;
-    } else {
-      delete process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE;
-    }
-    if (hadCreateArgs) {
-      process.env.FAWN_WEBGPU_CREATE_ARGS = previousCreateArgs;
-    } else {
-      delete process.env.FAWN_WEBGPU_CREATE_ARGS;
-    }
+    delete process.env.FAWN_WEBGPU_CREATE_ARGS;
   }
 }
 

package/src/training/checkpoint-watch.d.ts

@@ -0,0 +1,7 @@
+export declare function watchFinalizedCheckpoints(options: {
+  checkpointsDir: string;
+  manifestPath: string;
+  pollIntervalMs?: number | null;
+  stopWhenIdle?: boolean;
+  onCheckpoint: (markerPath: string) => Promise<void> | void;
+}): Promise<{ ok: true; processedCount: number; manifestPath: string }>;