@simulatte/doppler 0.1.8 → 0.2.0

package/src/tooling/command-api.d.ts

@@ -1,173 +0,0 @@
-import type { ConverterConfigSchema } from '../config/schema/converter.schema.js';
-
-export type ToolingCommand = 'convert' | 'debug' | 'bench' | 'verify' | 'lora' | 'distill';
-export type ToolingSurface = 'browser' | 'node';
-export type ToolingSuite = 'kernels' | 'inference' | 'training' | 'bench' | 'debug' | 'diffusion' | 'energy';
-export type ToolingIntent = 'verify' | 'investigate' | 'calibrate' | null;
-export type ToolingTrainingStage = 'stage1_joint' | 'stage2_base' | 'stage_a' | 'stage_b';
-export type ToolingDistillAction = 'run' | 'stage-a' | 'stage-b' | 'eval' | 'watch' | 'compare' | 'quality-gate' | 'subsets';
-export type ToolingLoraAction = 'run' | 'eval' | 'watch' | 'export' | 'compare' | 'quality-gate' | 'activate';
-
-export interface ToolingConvertExecutionPayload {
-  workers?: number | null;
-  workerCountPolicy?: 'cap' | 'error' | null;
-  maxInFlightJobs?: number | null;
-  rowChunkRows?: number | null;
-  rowChunkMinTensorBytes?: number | null;
-  useGpuCast?: boolean | null;
-  gpuCastMinTensorBytes?: number | null;
-  [key: string]: unknown;
-}
-
-export interface ToolingConvertPayload {
-  converterConfig: Partial<ConverterConfigSchema>;
-  execution?: ToolingConvertExecutionPayload | null;
-  [key: string]: unknown;
-}
-
-export interface ToolingCommandRequestInput {
-  command: ToolingCommand;
-  action?: ToolingDistillAction | ToolingLoraAction;
-  suite?: ToolingSuite;
-  modelId?: string;
-  trainingTests?: string[];
-  trainingStage?: ToolingTrainingStage;
-  trainingConfig?: Record<string, unknown>;
-  stage1Artifact?: string;
-  stage1ArtifactHash?: string;
-  ulArtifactDir?: string;
-  stageAArtifact?: string;
-  stageAArtifactHash?: string;
-  distillArtifactDir?: string;
-  teacherModelId?: string;
-  studentModelId?: string;
-  distillDatasetId?: string;
-  distillDatasetPath?: string;
-  distillLanguagePair?: string;
-  distillSourceLangs?: string[];
-  distillTargetLangs?: string[];
-  distillPairAllowlist?: string[];
-  strictPairContract?: boolean;
-  distillShardIndex?: number;
-  distillShardCount?: number;
-  resumeFrom?: string;
-  forceResume?: boolean;
-  forceResumeReason?: string;
-  forceResumeSource?: string;
-  checkpointOperator?: string;
-  trainingSchemaVersion?: number;
-  trainingBenchSteps?: number;
-  checkpointEvery?: number;
-  workloadType?: string;
-  modelUrl?: string;
-  cacheMode?: 'cold' | 'warm';
-  loadMode?: 'opfs' | 'http' | 'memory';
-  runtimePreset?: string;
-  runtimeConfigUrl?: string;
-  runtimeConfig?: Record<string, unknown>;
-  inputDir?: string;
-  outputDir?: string;
-  convertPayload?: ToolingConvertPayload;
-  workloadPath?: string;
-  runRoot?: string;
-  checkpointPath?: string;
-  checkpointId?: string;
-  checkpointStep?: number;
-  stageId?: string;
-  stageArtifact?: string;
-  subsetManifest?: string;
-  evalDatasetId?: string;
-  pollIntervalMs?: number;
-  stopWhenIdle?: boolean;
-  captureOutput?: boolean;
-  keepPipeline?: boolean;
-  report?: Record<string, unknown> | null;
-  timestamp?: string | Date | null;
-  searchParams?: URLSearchParams | null;
-}
-
-export interface ToolingCommandRequest {
-  command: ToolingCommand;
-  suite: ToolingSuite | null;
-  intent: ToolingIntent;
-  action: ToolingDistillAction | ToolingLoraAction | null;
-  modelId: string | null;
-  trainingTests: string[] | null;
-  trainingStage: ToolingTrainingStage | null;
-  trainingConfig: Record<string, unknown> | null;
-  stage1Artifact: string | null;
-  stage1ArtifactHash: string | null;
-  ulArtifactDir: string | null;
-  stageAArtifact: string | null;
-  stageAArtifactHash: string | null;
-  distillArtifactDir: string | null;
-  teacherModelId: string | null;
-  studentModelId: string | null;
-  distillDatasetId: string | null;
-  distillDatasetPath: string | null;
-  distillLanguagePair: string | null;
-  distillSourceLangs: string[] | null;
-  distillTargetLangs: string[] | null;
-  distillPairAllowlist: string[] | null;
-  strictPairContract: boolean | null;
-  distillShardIndex: number | null;
-  distillShardCount: number | null;
-  resumeFrom: string | null;
-  forceResume: boolean | null;
-  forceResumeReason: string | null;
-  forceResumeSource: string | null;
-  checkpointOperator: string | null;
-  trainingSchemaVersion: number | null;
-  trainingBenchSteps: number | null;
-  checkpointEvery: number | null;
-  workloadType: string | null;
-  modelUrl: string | null;
-  cacheMode: 'cold' | 'warm' | null;
-  loadMode: 'opfs' | 'http' | 'memory' | null;
-  runtimePreset: string | null;
-  runtimeConfigUrl: string | null;
-  runtimeConfig: Record<string, unknown> | null;
-  inputDir: string | null;
-  outputDir: string | null;
-  convertPayload: ToolingConvertPayload | null;
-  workloadPath: string | null;
-  runRoot: string | null;
-  checkpointPath: string | null;
-  checkpointId: string | null;
-  checkpointStep: number | null;
-  stageId: string | null;
-  stageArtifact: string | null;
-  subsetManifest: string | null;
-  evalDatasetId: string | null;
-  pollIntervalMs: number | null;
-  stopWhenIdle: boolean | null;
-  captureOutput: boolean;
-  keepPipeline: boolean;
-  report: Record<string, unknown> | null;
-  timestamp: string | Date | null;
-  searchParams: URLSearchParams | null;
-}
-
-export declare const TOOLING_COMMANDS: readonly ToolingCommand[];
-export declare const TOOLING_SURFACES: readonly ToolingSurface[];
-export declare const TOOLING_SUITES: readonly ToolingSuite[];
-export declare const TOOLING_VERIFY_SUITES: readonly Exclude<ToolingSuite, 'bench' | 'debug'>[];
-export declare const TOOLING_TRAINING_COMMAND_SCHEMA_VERSION: number;
-
-export declare function normalizeToolingCommandRequest(
-  input: ToolingCommandRequestInput
-): ToolingCommandRequest;
-
-export declare function buildRuntimeContractPatch(
-  commandRequest: ToolingCommandRequestInput
-): {
-  shared: {
-    harness: { mode: ToolingSuite; modelId: string | null };
-    tooling: { intent: Exclude<ToolingIntent, null> };
-  };
-} | null;
-
-export declare function ensureCommandSupportedOnSurface(
-  commandRequest: ToolingCommandRequestInput,
-  surface: ToolingSurface
-): { request: ToolingCommandRequest; surface: ToolingSurface };

package/src/tooling/command-api.js

@@ -1,76 +0,0 @@
-import { isPlainObject } from '../utils/plain-object.js';
-import {
-  TOOLING_COMMAND_SET,
-  TOOLING_SURFACE_SET,
-  TOOLING_SUITE_SET,
-  VERIFY_SUITES,
-  TRAINING_COMMAND_SCHEMA_VERSION,
-} from './command-api-constants.js';
-import {
-  asOptionalString,
-  assertCommand,
-} from './command-api-helpers.js';
-import {
-  normalizeConvert,
-  normalizeTrainingOperatorCommand,
-  normalizeSuiteCommand,
-} from './command-api-family-normalizers.js';
-
-export const TOOLING_COMMANDS = Object.freeze([...TOOLING_COMMAND_SET]);
-export const TOOLING_SURFACES = Object.freeze([...TOOLING_SURFACE_SET]);
-export const TOOLING_SUITES = Object.freeze([...TOOLING_SUITE_SET]);
-export const TOOLING_VERIFY_SUITES = Object.freeze([...VERIFY_SUITES]);
-export const TOOLING_TRAINING_COMMAND_SCHEMA_VERSION = TRAINING_COMMAND_SCHEMA_VERSION;
-
-export function normalizeToolingCommandRequest(input) {
-  if (!isPlainObject(input)) {
-    throw new Error('tooling command: request must be an object.');
-  }
-  const command = assertCommand(input.command);
-  if (command === 'convert') {
-    return normalizeConvert(input);
-  }
-  if (command === 'lora' || command === 'distill') {
-    return normalizeTrainingOperatorCommand(input, command);
-  }
-  return normalizeSuiteCommand(input, command);
-}
-
-export function buildRuntimeContractPatch(commandRequest) {
-  const request = normalizeToolingCommandRequest(commandRequest);
-  if (!request.suite || !request.intent) {
-    return null;
-  }
-
-  return {
-    shared: {
-      harness: {
-        mode: request.suite,
-        modelId: request.modelId ?? null,
-      },
-      tooling: {
-        intent: request.intent,
-      },
-    },
-  };
-}
-
-export function ensureCommandSupportedOnSurface(commandRequest, surface) {
-  const request = normalizeToolingCommandRequest(commandRequest);
-  const normalizedSurface = asOptionalString(surface, 'surface');
-  if (!normalizedSurface || !TOOLING_SURFACE_SET.includes(normalizedSurface)) {
-    throw new Error(`tooling command: unsupported surface "${surface}".`);
-  }
-
-  if (
-    normalizedSurface === 'browser'
-    && (request.command === 'lora' || request.command === 'distill')
-  ) {
-    throw new Error(`tooling command: ${request.command} is currently Node-only and must fail closed on browser.`);
-  }
-
-  return {
-    request,
-    surface: normalizedSurface,
-  };
-}

package/src/tooling/command-envelope.d.ts

@@ -1,81 +0,0 @@
-import type { ToolingCommandRequest } from './command-api.js';
-
-export declare const TOOLING_ENVELOPE_SCHEMA_VERSION: number;
-export declare const TOOLING_ERROR_CODE_FALLBACK: string;
-
-export interface ToolingCommandErrorDetails {
-  command?: string | null;
-  suite?: string | null;
-  workloadType?: string | null;
-  modelId?: string | null;
-  requestedSuite?: string | null;
-  allowedSuites?: string[] | null;
-  fromSurface?: string | null;
-  toSurface?: string | null;
-  surface?: string | null;
-  [key: string]: unknown;
-}
-
-export interface ToolingSuccessEnvelope<T = unknown> {
-  ok: true;
-  schemaVersion: number;
-  surface: string;
-  request: ToolingCommandRequest;
-  result: T;
-  meta?: Record<string, unknown> | null;
-}
-
-export interface ToolingErrorPayload {
-  code: string;
-  message: string;
-  details: ToolingCommandErrorDetails | null;
-  retryable: boolean | null;
-}
-
-export interface ToolingErrorEnvelope {
-  ok: false;
-  schemaVersion: number;
-  surface: string | null;
-  request: ToolingCommandRequest | null;
-  error: ToolingErrorPayload;
-}
-
-export interface ToolingCommandErrorOptions {
-  code?: string | null;
-  details?: ToolingCommandErrorDetails | null;
-  retryable?: boolean | null;
-  cause?: unknown;
-}
-
-export declare class ToolingCommandError extends Error {
-  code: string;
-  details: ToolingCommandErrorDetails | null;
-  retryable: boolean | null;
-  constructor(message: string, options?: ToolingCommandErrorOptions);
-}
-
-export declare function normalizeToToolingCommandError(
-  error: unknown,
-  context?: {
-    surface?: string | null;
-    request?: ToolingCommandRequest | null;
-  }
-): ToolingCommandError;
-
-export declare function createToolingSuccessEnvelope<T = unknown>(input: {
-  surface: string;
-  request: ToolingCommandRequest;
-  result: T;
-  meta?: Record<string, unknown> | null;
-}): ToolingSuccessEnvelope<T>;
-
-export declare function createToolingErrorEnvelope(
-  error: unknown,
-  context?: {
-    surface?: string | null;
-    request?: ToolingCommandRequest | null;
-  }
-): ToolingErrorEnvelope;
-
-export declare function isToolingSuccessEnvelope(value: unknown): value is ToolingSuccessEnvelope;
-export declare function isToolingErrorEnvelope(value: unknown): value is ToolingErrorEnvelope;

package/src/tooling/command-envelope.js

@@ -1,198 +0,0 @@
-import { isPlainObject } from '../utils/plain-object.js';
-
-export const TOOLING_ENVELOPE_SCHEMA_VERSION = 1;
-export const TOOLING_ERROR_CODE_FALLBACK = 'tooling_error';
-
-const CONTEXT_DETAIL_KEYS = Object.freeze([
-  'command',
-  'suite',
-  'workloadType',
-  'modelId',
-  'requestedSuite',
-  'allowedSuites',
-  'fromSurface',
-  'toSurface',
-  'surface',
-]);
-
-function asNonEmptyString(value) {
-  if (value == null) return null;
-  const normalized = String(value).trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
-function mergeDetailRecords(...sources) {
-  const merged = {};
-  for (const source of sources) {
-    if (!isPlainObject(source)) continue;
-    for (const [key, value] of Object.entries(source)) {
-      if (value === undefined) continue;
-      merged[key] = value;
-    }
-  }
-  return Object.keys(merged).length > 0 ? merged : null;
-}
-
-function pickKnownDetails(source) {
-  if (!isPlainObject(source)) return null;
-  const picked = {};
-  for (const key of CONTEXT_DETAIL_KEYS) {
-    if (source[key] !== undefined) {
-      picked[key] = source[key];
-    }
-  }
-  return Object.keys(picked).length > 0 ? picked : null;
-}
-
-function pickContextDetails(context) {
-  if (!isPlainObject(context)) return null;
-  const requestDetails = pickKnownDetails(context.request);
-  const surface = asNonEmptyString(context.surface);
-  return mergeDetailRecords(
-    surface ? { surface } : null,
-    requestDetails
-  );
-}
-
-function resolveErrorMessage(error) {
-  if (error && typeof error.message === 'string' && error.message.trim().length > 0) {
-    return error.message;
-  }
-  return String(error || 'Unknown tooling command error');
-}
-
-function resolveErrorCode(error) {
-  const explicit = asNonEmptyString(error?.code);
-  if (explicit) return explicit;
-  if (error?.name === 'AbortError') return 'aborted';
-  return TOOLING_ERROR_CODE_FALLBACK;
-}
-
-function resolveRetryable(error) {
-  if (typeof error?.retryable === 'boolean') {
-    return error.retryable;
-  }
-  const code = asNonEmptyString(error?.code);
-  if (code === 'ETIMEDOUT' || code === 'ECONNRESET' || code === 'EAI_AGAIN') {
-    return true;
-  }
-  return null;
-}
-
-export class ToolingCommandError extends Error {
-  constructor(message, options = {}) {
-    const text = asNonEmptyString(message) || 'Unknown tooling command error';
-    super(text, options.cause !== undefined ? { cause: options.cause } : undefined);
-    this.name = 'ToolingCommandError';
-    this.code = asNonEmptyString(options.code) || TOOLING_ERROR_CODE_FALLBACK;
-    this.details = isPlainObject(options.details) ? options.details : null;
-    this.retryable = typeof options.retryable === 'boolean' ? options.retryable : null;
-  }
-}
-
-export function normalizeToToolingCommandError(error, context = {}) {
-  if (error instanceof ToolingCommandError) {
-    const contextDetails = pickContextDetails(context);
-    if (!error.details && contextDetails) {
-      error.details = contextDetails;
-    } else if (error.details && contextDetails) {
-      error.details = mergeDetailRecords(error.details, contextDetails);
-    }
-    if (error.retryable == null) {
-      error.retryable = resolveRetryable(error);
-    }
-    return error;
-  }
-
-  const cause = error instanceof Error ? error : undefined;
-  const details = mergeDetailRecords(
-    isPlainObject(error?.details) ? error.details : null,
-    pickKnownDetails(error),
-    pickContextDetails(context)
-  );
-
-  const normalized = new ToolingCommandError(resolveErrorMessage(error), {
-    cause,
-    code: resolveErrorCode(error),
-    details,
-    retryable: resolveRetryable(error),
-  });
-  return normalized;
-}
-
-export function createToolingSuccessEnvelope({
-  surface,
-  request,
-  result,
-  meta = null,
-}) {
-  const normalizedSurface = asNonEmptyString(surface);
-  if (!normalizedSurface) {
-    throw new Error('tooling envelope: surface is required for success responses.');
-  }
-  if (!isPlainObject(request)) {
-    throw new Error('tooling envelope: request must be an object for success responses.');
-  }
-
-  return {
-    ok: true,
-    schemaVersion: TOOLING_ENVELOPE_SCHEMA_VERSION,
-    surface: normalizedSurface,
-    request,
-    result,
-    ...(meta == null ? {} : { meta }),
-  };
-}
-
-export function createToolingErrorEnvelope(error, context = {}) {
-  const normalized = normalizeToToolingCommandError(error, context);
-  const surface = asNonEmptyString(context?.surface)
-    || asNonEmptyString(normalized?.details?.surface)
-    || asNonEmptyString(error?.surface)
-    || null;
-  const request = isPlainObject(context?.request) ? context.request : null;
-  return {
-    ok: false,
-    schemaVersion: TOOLING_ENVELOPE_SCHEMA_VERSION,
-    surface,
-    request,
-    error: {
-      code: normalized.code,
-      message: normalized.message,
-      details: normalized.details ?? null,
-      retryable: normalized.retryable ?? null,
-    },
-  };
-}
-
-export function isToolingSuccessEnvelope(value) {
-  if (!isPlainObject(value)) return false;
-  return (
-    value.ok === true
-    && Number.isInteger(value.schemaVersion)
-    && value.schemaVersion === TOOLING_ENVELOPE_SCHEMA_VERSION
-    && typeof value.surface === 'string'
-    && isPlainObject(value.request)
-    && Object.prototype.hasOwnProperty.call(value, 'result')
-  );
-}
-
-export function isToolingErrorEnvelope(value) {
-  if (!isPlainObject(value)) return false;
-  if (value.ok !== false) return false;
-  if (!Number.isInteger(value.schemaVersion) || value.schemaVersion !== TOOLING_ENVELOPE_SCHEMA_VERSION) {
-    return false;
-  }
-  if (value.surface !== null && typeof value.surface !== 'string') {
-    return false;
-  }
-  if (value.request !== null && !isPlainObject(value.request)) {
-    return false;
-  }
-  if (!isPlainObject(value.error)) return false;
-  if (typeof value.error.code !== 'string' || !value.error.code.trim()) return false;
-  if (typeof value.error.message !== 'string' || !value.error.message.trim()) return false;
-  if (value.error.details !== null && !isPlainObject(value.error.details)) return false;
-  if (value.error.retryable !== null && typeof value.error.retryable !== 'boolean') return false;
-  return true;
-}

package/src/tooling/command-runner-shared.d.ts

@@ -1,73 +0,0 @@
-import type { RuntimeConfigLoadOptions } from '../inference/browser-harness.js';
-import type { ToolingCommandRequest } from './command-api.js';
-
-export interface RuntimeBridge {
-  applyRuntimePreset: (
-    runtimePreset: string,
-    options?: RuntimeConfigLoadOptions
-  ) => Promise<void>;
-  applyRuntimeConfigFromUrl: (
-    runtimeConfigUrl: string,
-    options?: RuntimeConfigLoadOptions
-  ) => Promise<void>;
-  getRuntimeConfig: () => Record<string, unknown>;
-  setRuntimeConfig: (runtimeConfig: Record<string, unknown> | null) => void;
-  getActiveKernelPath?: () => unknown;
-  getActiveKernelPathSource?: () => string;
-  getActiveKernelPathPolicy?: () => Record<string, unknown> | null;
-  setActiveKernelPath?: (path: unknown, source?: string, policy?: Record<string, unknown> | null) => void;
-}
-
-export declare function applyRuntimeInputs(
-  request: ToolingCommandRequest,
-  runtimeBridge: RuntimeBridge,
-  options?: RuntimeConfigLoadOptions
-): Promise<void>;
-
-export declare function buildSuiteOptions(
-  request: ToolingCommandRequest,
-  surface?: string | null
-): {
-  suite: ToolingCommandRequest['suite'];
-  command: ToolingCommandRequest['command'];
-  surface: string | null;
-  modelId?: string;
-  trainingTests?: string[];
-  trainingStage?: 'stage1_joint' | 'stage2_base' | 'stage_a' | 'stage_b';
-  trainingConfig?: Record<string, unknown>;
-  stage1Artifact?: string;
-  stage1ArtifactHash?: string;
-  ulArtifactDir?: string;
-  stageAArtifact?: string;
-  stageAArtifactHash?: string;
-  distillArtifactDir?: string;
-  teacherModelId?: string;
-  studentModelId?: string;
-  distillDatasetId?: string;
-  distillDatasetPath?: string;
-  distillLanguagePair?: string;
-  distillSourceLangs?: string[];
-  distillTargetLangs?: string[];
-  distillPairAllowlist?: string[];
-  strictPairContract?: boolean;
-  distillShardIndex?: number;
-  distillShardCount?: number;
-  resumeFrom?: string;
-  forceResume?: boolean;
-  forceResumeReason?: string;
-  forceResumeSource?: string;
-  checkpointOperator?: string;
-  trainingSchemaVersion?: number;
-  trainingBenchSteps?: number;
-  checkpointEvery?: number;
-  workloadType?: string;
-  cacheMode: ToolingCommandRequest['cacheMode'];
-  loadMode: 'opfs' | 'http' | 'memory' | null;
-  modelUrl?: string;
-  runtimePreset: string | null;
-  captureOutput: boolean;
-  keepPipeline: boolean;
-  report?: Record<string, unknown>;
-  timestamp?: string | Date;
-  searchParams?: URLSearchParams;
-};