@simulatte/doppler 0.1.8 → 0.2.0

package/src/config/schema/ul-training.schema.js

@@ -1,140 +0,0 @@
-export const UL_STAGE_VALUES = Object.freeze(['stage1_joint', 'stage2_base']);
-export const UL_TRAINING_SCHEMA_VERSION = 1;
-
-export const DEFAULT_UL_NOISE_SCHEDULE = Object.freeze({
-  type: 'log_snr_linear',
-  minLogSNR: -4,
-  maxLogSNR: 5,
-  steps: 64,
-});
-
-export const DEFAULT_UL_PRIOR_ALIGNMENT = Object.freeze({
-  enabled: true,
-  weight: 1,
-});
-
-export const DEFAULT_UL_DECODER_SIGMOID_WEIGHT = Object.freeze({
-  enabled: true,
-  slope: 1,
-  midpoint: 0,
-});
-
-export const DEFAULT_UL_FREEZE_GROUPS = Object.freeze({
-  encoder: false,
-  prior: false,
-  decoder: false,
-  base: false,
-  lora: false,
-});
-
-export const DEFAULT_UL_LOSS_WEIGHTS = Object.freeze({
-  ce: 1,
-  prior: 1,
-  decoder: 1,
-  recon: 1,
-});
-
-export const DEFAULT_UL_TRAINING_CONFIG = Object.freeze({
-  schemaVersion: UL_TRAINING_SCHEMA_VERSION,
-  enabled: false,
-  stage: 'stage1_joint',
-  lambda0: 5,
-  seed: 1337,
-  artifactDir: 'reports/training/ul',
-  stage1Artifact: null,
-  stage1ArtifactHash: null,
-  noiseSchedule: DEFAULT_UL_NOISE_SCHEDULE,
-  priorAlignment: DEFAULT_UL_PRIOR_ALIGNMENT,
-  decoderSigmoidWeight: DEFAULT_UL_DECODER_SIGMOID_WEIGHT,
-  lossWeights: DEFAULT_UL_LOSS_WEIGHTS,
-  freeze: DEFAULT_UL_FREEZE_GROUPS,
-});
-
-function assertFiniteNumber(value, label) {
-  if (typeof value !== 'number' || !Number.isFinite(value)) {
-    throw new Error(`UL config: ${label} must be a finite number.`);
-  }
-}
-
-function assertBoolean(value, label) {
-  if (typeof value !== 'boolean') {
-    throw new Error(`UL config: ${label} must be a boolean.`);
-  }
-}
-
-function assertNullableString(value, label) {
-  if (value === null) return;
-  if (typeof value === 'string' && value.trim().length > 0) return;
-  throw new Error(`UL config: ${label} must be a non-empty string or null.`);
-}
-
-export function validateUlTrainingConfig(config) {
-  if (!config || typeof config !== 'object' || Array.isArray(config)) {
-    throw new Error('UL config: expected an object.');
-  }
-  assertFiniteNumber(config.schemaVersion, 'schemaVersion');
-  if (!UL_STAGE_VALUES.includes(config.stage)) {
-    throw new Error(`UL config: stage must be one of ${UL_STAGE_VALUES.join(', ')}.`);
-  }
-  assertBoolean(config.enabled, 'enabled');
-  assertFiniteNumber(config.lambda0, 'lambda0');
-  assertFiniteNumber(config.seed, 'seed');
-  assertNullableString(config.artifactDir, 'artifactDir');
-  assertNullableString(config.stage1Artifact, 'stage1Artifact');
-  assertNullableString(config.stage1ArtifactHash, 'stage1ArtifactHash');
-
-  const noiseSchedule = config.noiseSchedule;
-  if (!noiseSchedule || typeof noiseSchedule !== 'object' || Array.isArray(noiseSchedule)) {
-    throw new Error('UL config: noiseSchedule must be an object.');
-  }
-  if (typeof noiseSchedule.type !== 'string' || !noiseSchedule.type.trim()) {
-    throw new Error('UL config: noiseSchedule.type must be a non-empty string.');
-  }
-  assertFiniteNumber(noiseSchedule.minLogSNR, 'noiseSchedule.minLogSNR');
-  assertFiniteNumber(noiseSchedule.maxLogSNR, 'noiseSchedule.maxLogSNR');
-  assertFiniteNumber(noiseSchedule.steps, 'noiseSchedule.steps');
-
-  const priorAlignment = config.priorAlignment;
-  if (!priorAlignment || typeof priorAlignment !== 'object' || Array.isArray(priorAlignment)) {
-    throw new Error('UL config: priorAlignment must be an object.');
-  }
-  assertBoolean(priorAlignment.enabled, 'priorAlignment.enabled');
-  assertFiniteNumber(priorAlignment.weight, 'priorAlignment.weight');
-
-  const decoderSigmoidWeight = config.decoderSigmoidWeight;
-  if (
-    !decoderSigmoidWeight
-    || typeof decoderSigmoidWeight !== 'object'
-    || Array.isArray(decoderSigmoidWeight)
-  ) {
-    throw new Error('UL config: decoderSigmoidWeight must be an object.');
-  }
-  assertBoolean(decoderSigmoidWeight.enabled, 'decoderSigmoidWeight.enabled');
-  assertFiniteNumber(decoderSigmoidWeight.slope, 'decoderSigmoidWeight.slope');
-  assertFiniteNumber(decoderSigmoidWeight.midpoint, 'decoderSigmoidWeight.midpoint');
-
-  const lossWeights = config.lossWeights;
-  if (!lossWeights || typeof lossWeights !== 'object' || Array.isArray(lossWeights)) {
-    throw new Error('UL config: lossWeights must be an object.');
-  }
-  assertFiniteNumber(lossWeights.ce, 'lossWeights.ce');
-  assertFiniteNumber(lossWeights.prior, 'lossWeights.prior');
-  assertFiniteNumber(lossWeights.decoder, 'lossWeights.decoder');
-  assertFiniteNumber(lossWeights.recon, 'lossWeights.recon');
-
-  const freeze = config.freeze;
-  if (!freeze || typeof freeze !== 'object' || Array.isArray(freeze)) {
-    throw new Error('UL config: freeze must be an object.');
-  }
-  assertBoolean(freeze.encoder, 'freeze.encoder');
-  assertBoolean(freeze.prior, 'freeze.prior');
-  assertBoolean(freeze.decoder, 'freeze.decoder');
-  assertBoolean(freeze.base, 'freeze.base');
-  assertBoolean(freeze.lora, 'freeze.lora');
-
-  if (config.stage === 'stage2_base' && !config.stage1Artifact) {
-    throw new Error('UL config: stage2_base requires stage1Artifact.');
-  }
-
-  return config;
-}

package/src/config/schema/units.schema.d.ts

@@ -1,27 +0,0 @@
-/**
- * Unit Constants (Invariants)
- *
- * Single source of truth for byte unit conversions.
- * These are mathematical constants, not tunables.
- */
-
-/** 1 Kilobyte = 1024 bytes */
-export declare const KB: number;
-
-/** 1 Megabyte = 1024 * 1024 bytes */
-export declare const MB: number;
-
-/** 1 Gigabyte = 1024 * 1024 * 1024 bytes */
-export declare const GB: number;
-
-/**
- * Format bytes as human-readable string with units.
- * Example: 1536 -> "1.5 KB"
- */
-export declare function formatBytes(bytes: number): string;
-
-/**
- * Format bytes as compact string without spaces.
- * Example: 1536 -> "2KB"
- */
-export declare function formatBytesCompact(bytes: number): string;

package/src/config/schema/units.schema.js

@@ -1,26 +0,0 @@
-// =============================================================================
-// Unit Constants (Invariants)
-// =============================================================================
-// These are mathematical constants, not tunables.
-// Single source of truth for byte unit conversions.
-
-export const KB = 1024;
-export const MB = 1024 * 1024;
-export const GB = 1024 * 1024 * 1024;
-
-// =============================================================================
-// Format Helpers
-// =============================================================================
-
-export function formatBytes(bytes) {
-  if (bytes < KB) return `${bytes} B`;
-  if (bytes < MB) return `${(bytes / KB).toFixed(1)} KB`;
-  if (bytes < GB) return `${(bytes / MB).toFixed(1)} MB`;
-  return `${(bytes / GB).toFixed(1)} GB`;
-}
-
-export function formatBytesCompact(bytes) {
-  if (bytes < MB) return `${(bytes / KB).toFixed(0)}KB`;
-  if (bytes < GB) return `${(bytes / MB).toFixed(0)}MB`;
-  return `${(bytes / GB).toFixed(1)}GB`;
-}

package/src/config/training-defaults.d.ts

@@ -1,24 +0,0 @@
-import type { DopplerConfigSchema } from './schema/doppler.schema.js';
-import type { TrainingSettingsSchema } from './schema/training.schema.js';
-
-export interface TrainingConfigSchema extends DopplerConfigSchema {
-  training: TrainingSettingsSchema;
-}
-
-export interface TrainingConfigOverrides {
-  model?: DopplerConfigSchema['model'];
-  runtime?: Partial<DopplerConfigSchema['runtime']>;
-  training?: Partial<TrainingSettingsSchema>;
-}
-
-export declare const DEFAULT_TRAINING_CONFIG: TrainingConfigSchema;
-
-export declare function createTrainingConfig(
-  overrides?: TrainingConfigOverrides
-): TrainingConfigSchema;
-
-export declare function getTrainingConfig(): TrainingConfigSchema;
-export declare function setTrainingConfig(
-  overrides?: TrainingConfigOverrides
-): TrainingConfigSchema;
-export declare function resetTrainingConfig(): TrainingConfigSchema;

package/src/config/training-defaults.js

@@ -1,99 +0,0 @@
-import { createDopplerConfig, DEFAULT_TRAINING_SETTINGS } from './schema/index.js';
-import { validateDistillTrainingConfig } from './schema/distill-training.schema.js';
-import { validateUlTrainingConfig } from './schema/ul-training.schema.js';
-
-function cloneConfigTree(value) {
-  if (typeof structuredClone === 'function') {
-    return structuredClone(value);
-  }
-  return JSON.parse(JSON.stringify(value));
-}
-
-function mergeTrainingSettings(base, overrides) {
-  const baseConfig = cloneConfigTree(base);
-  if (!overrides) {
-    const merged = baseConfig;
-    validateDistillTrainingConfig(merged.distill);
-    validateUlTrainingConfig(merged.ul);
-    if (merged.distill.enabled === true && merged.ul.enabled === true) {
-      throw new Error('training config: distill and ul modes cannot both be enabled.');
-    }
-    return merged;
-  }
-
-  const merged = {
-    enabled: overrides.enabled ?? baseConfig.enabled,
-    lora: { ...baseConfig.lora, ...overrides.lora },
-    optimizer: {
-      ...baseConfig.optimizer,
-      ...overrides.optimizer,
-      scheduler: { ...baseConfig.optimizer.scheduler, ...overrides.optimizer?.scheduler },
-    },
-    gradient: { ...baseConfig.gradient, ...overrides.gradient },
-    precision: { ...baseConfig.precision, ...overrides.precision },
-    attention: { ...baseConfig.attention, ...overrides.attention },
-    telemetry: {
-      ...baseConfig.telemetry,
-      ...overrides.telemetry,
-      alerts: {
-        ...baseConfig.telemetry.alerts,
-        ...overrides.telemetry?.alerts,
-        thresholds: {
-          ...baseConfig.telemetry.alerts.thresholds,
-          ...overrides.telemetry?.alerts?.thresholds,
-        },
-      },
-    },
-    lossScaling: { ...baseConfig.lossScaling, ...overrides.lossScaling },
-    distill: {
-      ...baseConfig.distill,
-      ...overrides.distill,
-      freeze: { ...baseConfig.distill.freeze, ...overrides.distill?.freeze },
-    },
-    ul: {
-      ...baseConfig.ul,
-      ...overrides.ul,
-      noiseSchedule: { ...baseConfig.ul.noiseSchedule, ...overrides.ul?.noiseSchedule },
-      priorAlignment: { ...baseConfig.ul.priorAlignment, ...overrides.ul?.priorAlignment },
-      decoderSigmoidWeight: { ...baseConfig.ul.decoderSigmoidWeight, ...overrides.ul?.decoderSigmoidWeight },
-      lossWeights: { ...baseConfig.ul.lossWeights, ...overrides.ul?.lossWeights },
-      freeze: { ...baseConfig.ul.freeze, ...overrides.ul?.freeze },
-    },
-  };
-  validateDistillTrainingConfig(merged.distill);
-  validateUlTrainingConfig(merged.ul);
-  if (merged.distill.enabled === true && merged.ul.enabled === true) {
-    throw new Error('training config: distill and ul modes cannot both be enabled.');
-  }
-  return merged;
-}
-
-export function createTrainingConfig(overrides = {}) {
-  const dopplerConfig = createDopplerConfig({
-    model: overrides.model,
-    runtime: overrides.runtime,
-  });
-
-  return {
-    ...dopplerConfig,
-    training: mergeTrainingSettings(DEFAULT_TRAINING_SETTINGS, overrides.training),
-  };
-}
-
-export const DEFAULT_TRAINING_CONFIG = createTrainingConfig();
-
-let trainingConfig = createTrainingConfig();
-
-export function getTrainingConfig() {
-  return trainingConfig;
-}
-
-export function setTrainingConfig(overrides) {
-  trainingConfig = createTrainingConfig(overrides);
-  return trainingConfig;
-}
-
-export function resetTrainingConfig() {
-  trainingConfig = createTrainingConfig();
-  return trainingConfig;
-}

package/src/converter/conversion-plan.d.ts

@@ -1,64 +0,0 @@
-import type { ConverterConfigSchema } from '../config/schema/converter.schema.js';
-
-export interface ConversionPlanInputTensor {
-  name: string;
-  dtype?: string | null;
-}
-
-export interface ResolveConversionPlanOptions {
-  rawConfig: Record<string, unknown> | null | undefined;
-  tensors?: ConversionPlanInputTensor[] | null;
-  tensorNames?: string[] | null;
-  converterConfig: ConverterConfigSchema;
-  sourceQuantization?: string | null;
-  modelKind?: 'transformer' | 'diffusion';
-  architectureHint?: string | null;
-  architecture?: string | null;
-  architectureConfig?: { headDim?: number | null } | null;
-  headDim?: number | null;
-  headDimErrorMessage?: string | null;
-  presetOverride?: string | null;
-  includePresetOverrideHint?: boolean;
-}
-
-export interface ConversionPlanResult {
-  modelType: string;
-  presetId: string;
-  preset: Record<string, unknown> | null;
-  sourceQuantization: string;
-  quantizationInfo: Record<string, unknown>;
-  manifestQuantization: string;
-  manifestInference: Record<string, unknown>;
-  headDim?: number;
-}
-
-export interface ValidateKernelPathContext {
-  presetId?: string | null;
-  quantizationInfo?: {
-    weights?: string | null;
-    compute?: string | null;
-    layout?: string | null;
-  } | null;
-}
-
-export interface ResolveConvertedModelIdOptions {
-  explicitModelId?: string | null;
-  converterConfig?: ConverterConfigSchema | null;
-  detectedModelId?: string | null;
-  fallbackModelId?: string | null;
-  quantizationInfo?: { variantTag?: string | null } | null;
-  sanitizeOnly?: boolean;
-}
-
-export declare function inferSourceWeightQuantization(
-  tensors: ConversionPlanInputTensor[] | null | undefined
-): string;
-
-export declare function validateDefaultKernelPath(
-  inference: { defaultKernelPath?: string | null } | null | undefined,
-  context?: ValidateKernelPathContext
-): void;
-
-export declare function resolveConversionPlan(options: ResolveConversionPlanOptions): ConversionPlanResult;
-
-export declare function resolveConvertedModelId(options: ResolveConvertedModelIdOptions): string | null;