@simulatte/doppler 0.1.2 → 0.1.4

package/src/config/execution-contract-check.js

@@ -0,0 +1,245 @@
+import { DEFAULT_BATCHING_DEFAULTS, DEFAULT_GENERATION_CONFIG } from './schema/inference-defaults.schema.js';
+import { DEFAULT_KVCACHE_CONFIG } from './schema/kvcache.schema.js';
+
+const KV_LAYOUTS = new Set(['contiguous', 'paged', 'tiered', 'bdpa']);
+const PHASES = new Set(['prefill', 'decode', 'both']);
+const COLD_QUANT_MODES = new Set(['none', 'int8', 'int4']);
+const ATTENTION_OPS = new Set(['attention']);
+const EMBED_OPS = new Set(['embed', 'gather']);
+const SAMPLE_OPS = new Set(['sample']);
+const BDPA_MAX_HEAD_DIM = 256;
+const BDPA_MAX_KV_LEN = 2048;
+const TIERED_MAX_QUANT_HEAD_DIM = 256;
+
+function isPlainObject(value) {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function assertManifestObject(manifest) {
+  if (!isPlainObject(manifest)) {
+    throw new Error('execution contract: manifest must be an object.');
+  }
+  return manifest;
+}
+
+function assertPositiveInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`execution contract: ${label} must be a non-negative integer.`);
+  }
+  return value;
+}
+
+function assertPositiveIntegerOrDefault(value, fallback, label) {
+  if (value == null) {
+    return assertPositiveInteger(fallback, `${label} fallback`);
+  }
+  return assertPositiveInteger(value, label);
+}
+
+function normalizeKVLayout(value) {
+  const normalized = String(value ?? DEFAULT_KVCACHE_CONFIG.layout).trim().toLowerCase();
+  if (!KV_LAYOUTS.has(normalized)) {
+    throw new Error(
+      `execution contract: unsupported KV layout "${value}". ` +
+      `Expected one of ${[...KV_LAYOUTS].join(', ')}.`
+    );
+  }
+  return normalized;
+}
+
+function normalizePhase(value, label) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!PHASES.has(normalized)) {
+    throw new Error(
+      `execution contract: ${label} must be one of ${[...PHASES].join(', ')}.`
+    );
+  }
+  return normalized;
+}
+
+function normalizeColdQuantMode(kvcache) {
+  const tieringMode = String(
+    kvcache?.tiering?.mode
+      ?? DEFAULT_KVCACHE_CONFIG.tiering.mode
+  ).trim().toLowerCase();
+  if (tieringMode === 'off' || tieringMode === 'fp16') {
+    return 'none';
+  }
+  if (!COLD_QUANT_MODES.has(tieringMode)) {
+    throw new Error(
+      `execution contract: unsupported tiered cold quant mode "${tieringMode}".`
+    );
+  }
+  return tieringMode;
+}
+
+function classifyOp(op) {
+  const normalized = String(op ?? '').trim().toLowerCase();
+  if (!normalized) {
+    throw new Error('execution contract: execution step op is required.');
+  }
+  if (ATTENTION_OPS.has(normalized)) return 'attention';
+  if (EMBED_OPS.has(normalized)) return 'embed';
+  if (SAMPLE_OPS.has(normalized)) return 'sample';
+  if (normalized.includes('norm')) return 'norm';
+  if (normalized.includes('residual')) return 'residual';
+  if (normalized.endsWith('_proj') || normalized.startsWith('rope_') || normalized === 'activation') {
+    return 'projection';
+  }
+  return 'other';
+}
+
+export function sanitizeLeanModuleName(value) {
+  const raw = String(value ?? 'GeneratedExecutionContractCheck').trim();
+  const alnum = raw.replace(/[^A-Za-z0-9_]/g, '_');
+  if (!alnum) {
+    return 'GeneratedExecutionContractCheck';
+  }
+  if (/^[A-Za-z_]/.test(alnum)) {
+    return alnum;
+  }
+  return `Generated_${alnum}`;
+}
+
+export function extractExecutionContractFacts(manifest) {
+  const normalizedManifest = assertManifestObject(manifest);
+  const modelId = String(normalizedManifest.modelId ?? 'model').trim() || 'model';
+  const architecture = isPlainObject(normalizedManifest.architecture)
+    ? normalizedManifest.architecture
+    : {};
+  const inference = isPlainObject(normalizedManifest.inference)
+    ? normalizedManifest.inference
+    : {};
+  const sessionDefaults = isPlainObject(inference.sessionDefaults)
+    ? inference.sessionDefaults
+    : {};
+  const execution = isPlainObject(inference.execution)
+    ? inference.execution
+    : {};
+  const kvcache = isPlainObject(sessionDefaults.kvcache)
+    ? sessionDefaults.kvcache
+    : {};
+  const decodeLoop = isPlainObject(sessionDefaults.decodeLoop)
+    ? sessionDefaults.decodeLoop
+    : {};
+
+  const steps = Array.isArray(execution.steps)
+    ? execution.steps.map((step, index) => {
+      if (!isPlainObject(step)) {
+        throw new Error(`execution contract: execution.steps[${index}] must be an object.`);
+      }
+      const id = String(step.id ?? '').trim();
+      if (!id) {
+        throw new Error(`execution contract: execution.steps[${index}].id is required.`);
+      }
+      return {
+        id,
+        phase: normalizePhase(step.phase, `execution.steps[${index}].phase`),
+        opClass: classifyOp(step.op),
+      };
+    })
+    : [];
+
+  return {
+    modelId,
+    session: {
+      layout: normalizeKVLayout(kvcache.layout),
+      disableCommandBatching: decodeLoop.disableCommandBatching
+        ?? DEFAULT_GENERATION_CONFIG.disableCommandBatching,
+      decodeBatchSize: assertPositiveIntegerOrDefault(
+        decodeLoop.batchSize,
+        DEFAULT_BATCHING_DEFAULTS.batchSize,
+        'sessionDefaults.decodeLoop.batchSize'
+      ),
+      headDim: assertPositiveInteger(architecture.headDim, 'architecture.headDim'),
+      kvLen: assertPositiveIntegerOrDefault(
+        architecture.maxSeqLen ?? kvcache.maxSeqLen,
+        DEFAULT_KVCACHE_CONFIG.maxSeqLen,
+        'architecture.maxSeqLen'
+      ),
+      coldQuantMode: normalizeColdQuantMode(kvcache),
+    },
+    steps,
+  };
+}
+
+export function validateExecutionContractFacts(facts) {
+  const errors = [];
+  const checks = [];
+  const modelId = String(facts?.modelId ?? 'model');
+  const session = facts?.session ?? {};
+  const steps = Array.isArray(facts?.steps) ? facts.steps : [];
+
+  const incompatibleStep = session.layout === 'bdpa'
+    ? steps.find((step) => step.opClass === 'attention' && (step.phase === 'prefill' || step.phase === 'both'))
+    : null;
+  if (incompatibleStep) {
+    errors.push(
+      `[ExecutionContract] sessionDefaults.kvcache.layout="bdpa" is decode-only, ` +
+      `but step "${incompatibleStep.id}" declares ${incompatibleStep.phase} attention.`
+    );
+  }
+  checks.push({
+    id: `${modelId}.steps`,
+    ok: incompatibleStep == null,
+  });
+
+  const sessionErrorCount = errors.length;
+  if (session.layout === 'bdpa') {
+    if (session.disableCommandBatching !== true) {
+      errors.push(
+        '[ExecutionContract] sessionDefaults.kvcache.layout="bdpa" requires ' +
+        'sessionDefaults.decodeLoop.disableCommandBatching=true.'
+      );
+    }
+    if (session.decodeBatchSize > 1) {
+      errors.push(
+        `[ExecutionContract] sessionDefaults.kvcache.layout="bdpa" requires ` +
+        `sessionDefaults.decodeLoop.batchSize <= 1; got ${session.decodeBatchSize}.`
+      );
+    }
+    if (session.headDim > BDPA_MAX_HEAD_DIM) {
+      errors.push(
+        `[ExecutionContract] sessionDefaults.kvcache.layout="bdpa" requires architecture.headDim <= ${BDPA_MAX_HEAD_DIM}; ` +
+        `got ${session.headDim}.`
+      );
+    }
+    if (session.kvLen > BDPA_MAX_KV_LEN) {
+      errors.push(
+        `[ExecutionContract] sessionDefaults.kvcache.layout="bdpa" requires architecture.maxSeqLen <= ${BDPA_MAX_KV_LEN}; ` +
+        `got ${session.kvLen}.`
+      );
+    }
+  }
+
+  if (
+    session.layout === 'tiered'
+    && session.coldQuantMode !== 'none'
+    && session.headDim > TIERED_MAX_QUANT_HEAD_DIM
+  ) {
+    errors.push(
+      `[ExecutionContract] sessionDefaults.kvcache.layout="tiered" with cold quantization requires ` +
+      `architecture.headDim <= ${TIERED_MAX_QUANT_HEAD_DIM}; got ${session.headDim}.`
+    );
+  }
+
+  checks.push({
+    id: `${modelId}.session`,
+    ok: errors.length === sessionErrorCount,
+  });
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    checks,
+  };
+}
+
+export function validateManifestExecutionContract(manifest) {
+  const facts = extractExecutionContractFacts(manifest);
+  const evaluation = validateExecutionContractFacts(facts);
+  return {
+    ...evaluation,
+    facts,
+  };
+}

package/src/config/loader.js

@@ -14,6 +14,7 @@ const gemma3Preset = await loadJson('./presets/models/gemma3.json', import.meta.
 const translateGemmaPreset = await loadJson('./presets/models/translategemma.json', import.meta.url, 'Failed to load preset');
 const embeddingGemmaPreset = await loadJson('./presets/models/embeddinggemma.json', import.meta.url, 'Failed to load preset');
 const functiongemmaPreset = await loadJson('./presets/models/functiongemma.json', import.meta.url, 'Failed to load preset');
+const janusTextPreset = await loadJson('./presets/models/janus-text.json', import.meta.url, 'Failed to load preset');
 const llama3Preset = await loadJson('./presets/models/llama3.json', import.meta.url, 'Failed to load preset');
 const mixtralPreset = await loadJson('./presets/models/mixtral.json', import.meta.url, 'Failed to load preset');
 const deepseekPreset = await loadJson('./presets/models/deepseek.json', import.meta.url, 'Failed to load preset');
@@ -36,6 +37,7 @@ export const PRESET_REGISTRY = {
   translategemma: translateGemmaPreset,
   embeddinggemma: embeddingGemmaPreset,
   functiongemma: functiongemmaPreset,
+  janus_text: janusTextPreset,
   llama3: llama3Preset,
   mixtral: mixtralPreset,
   deepseek: deepseekPreset,
@@ -85,6 +87,7 @@ export const PRESET_DETECTION_ORDER = [
   // Most specific first (model variants)
   'functiongemma',
   'embeddinggemma',
+  'janus_text',
   'modernbert',
   'diffusion',
   // Model families (check more specific patterns first)
@@ -107,8 +110,9 @@ export function detectPreset(
   config,
   architecture
 ) {
+  const nestedTextConfig = getNestedTextConfig(config);
   const archLower = (architecture || '').toLowerCase();
-  const modelType = (config.model_type || '').toLowerCase();
+  const modelType = String(nestedTextConfig?.model_type ?? config.model_type ?? '').toLowerCase();
   // Weak hint case: architecture fallback is often model_type copy (e.g. qwen2).
   const hintsAreWeak = !archLower || !modelType || archLower === modelType;
 
@@ -317,41 +321,56 @@ function assertArchitecture(manifest, architecture) {
 // =============================================================================
 
 function extractArchitectureFromConfig(config) {
+  const nestedTextConfig = getNestedTextConfig(config);
   return {
-    numLayers: config.num_hidden_layers ?? config.n_layer ?? config.blockCount,
-    hiddenSize: config.hidden_size ?? config.n_embd ?? config.embeddingLength,
-    intermediateSize: config.intermediate_size ?? config.n_inner ?? config.feedForwardLength,
-    numAttentionHeads: config.num_attention_heads ?? config.n_head ?? config.attentionHeadCount,
-    numKeyValueHeads: config.num_key_value_heads ?? config.attentionHeadCountKV,
-    headDim: config.head_dim,
-    vocabSize: config.vocab_size ?? config.vocabSize,
-    maxSeqLen: config.max_position_embeddings ?? config.n_positions ?? config.contextLength,
-    ropeTheta: config.rope_theta ?? config.ropeFreqBase,
-    rmsNormEps: config.rms_norm_eps ?? config.attentionLayerNormRMSEpsilon,
+    numLayers: config.num_hidden_layers ?? nestedTextConfig?.num_hidden_layers ?? config.n_layer ?? config.blockCount,
+    hiddenSize: config.hidden_size ?? nestedTextConfig?.hidden_size ?? config.n_embd ?? config.embeddingLength,
+    intermediateSize: config.intermediate_size ?? nestedTextConfig?.intermediate_size ?? config.n_inner ?? config.feedForwardLength,
+    numAttentionHeads: config.num_attention_heads ?? nestedTextConfig?.num_attention_heads ?? config.n_head ?? config.attentionHeadCount,
+    numKeyValueHeads: config.num_key_value_heads ?? nestedTextConfig?.num_key_value_heads ?? config.attentionHeadCountKV,
+    headDim: config.head_dim ?? nestedTextConfig?.head_dim,
+    vocabSize: config.vocab_size ?? nestedTextConfig?.vocab_size ?? config.vocabSize,
+    maxSeqLen: config.max_position_embeddings ?? nestedTextConfig?.max_position_embeddings ?? config.n_positions ?? config.contextLength,
+    ropeTheta: config.rope_theta ?? nestedTextConfig?.rope_theta ?? config.ropeFreqBase,
+    rmsNormEps: config.rms_norm_eps ?? nestedTextConfig?.rms_norm_eps ?? config.attentionLayerNormRMSEpsilon,
   };
 }
 
 function extractInferenceFromConfig(config) {
+  const nestedTextConfig = getNestedTextConfig(config);
   return {
     attention: {
-      slidingWindow: config.sliding_window,
-      attnLogitSoftcapping: config.attn_logit_softcapping,
-      attentionOutputGate: config.attn_output_gate,
+      slidingWindow: config.sliding_window ?? nestedTextConfig?.sliding_window,
+      attnLogitSoftcapping: config.attn_logit_softcapping ?? nestedTextConfig?.attn_logit_softcapping,
+      attentionOutputGate: config.attn_output_gate ?? nestedTextConfig?.attn_output_gate,
     },
     output: {
-      finalLogitSoftcapping: config.final_logit_softcapping,
-      tieWordEmbeddings: config.tie_word_embeddings,
-      scaleEmbeddings: config.scale_embeddings,
+      finalLogitSoftcapping: config.final_logit_softcapping ?? nestedTextConfig?.final_logit_softcapping,
+      tieWordEmbeddings: config.tie_word_embeddings ?? nestedTextConfig?.tie_word_embeddings,
+      scaleEmbeddings: config.scale_embeddings ?? nestedTextConfig?.scale_embeddings,
     },
-    pipeline: config.pipeline,
+    pipeline: config.pipeline ?? nestedTextConfig?.pipeline,
     rope: {
-      ropeTheta: config.rope_theta ?? config.ropeFreqBase,
-      ropeScalingType: config.rope_scaling_type,
-      ropeScalingFactor: config.rope_scaling_factor,
+      ropeTheta: config.rope_theta ?? nestedTextConfig?.rope_theta ?? config.ropeFreqBase,
+      ropeScalingType: config.rope_scaling_type ?? nestedTextConfig?.rope_scaling_type,
+      ropeScalingFactor: config.rope_scaling_factor ?? nestedTextConfig?.rope_scaling_factor,
     },
   };
 }
 
+function getNestedTextConfig(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return null;
+  }
+  if (config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)) {
+    return config.text_config;
+  }
+  if (config.language_config && typeof config.language_config === 'object' && !Array.isArray(config.language_config)) {
+    return config.language_config;
+  }
+  return null;
+}
+
 function extractTokenizerFromManifest(manifest) {
   if (!manifest.tokenizer) return {};
 

package/src/config/presets/models/janus-text.json

@@ -0,0 +1,25 @@
+{
+  "id": "janus_text",
+  "name": "Janus Text Core",
+  "extends": "transformer",
+  "modelType": "transformer",
+
+  "inference": {
+    "normalization": {
+      "rmsNormEps": 1e-6
+    },
+    "rope": {
+      "ropeTheta": 10000
+    }
+  },
+
+  "tokenizer": {
+    "addBosToken": true,
+    "addEosToken": false
+  },
+
+  "detection": {
+    "architecturePatterns": ["JanusTextForCausalLM"],
+    "modelTypePatterns": ["janus_text"]
+  }
+}

package/src/converter/core.js

@@ -76,7 +76,8 @@ function resolveTokenizerField(tokenizerConfig, ...keys) {
 }
 
 function resolveTokenizerVocabSize(tokenizerConfig, rawConfig, architecture) {
-  const configVocab = rawConfig?.vocab_size ?? rawConfig?.text_config?.vocab_size;
+  const nestedTextConfig = getNestedTextConfig(rawConfig);
+  const configVocab = rawConfig?.vocab_size ?? nestedTextConfig?.vocab_size;
   const tokenizerVocab = tokenizerConfig?.vocab_size ?? tokenizerConfig?.vocabSize;
   const archVocab = architecture?.vocabSize;
   return tokenizerVocab ?? configVocab ?? archVocab ?? null;
@@ -223,21 +224,22 @@ function toFloat32ForQ4K(tensorData, sourceDtype, tensorName) {
 
 function resolveConfigTokenId(rawConfig, key) {
   const direct = rawConfig?.[key];
-  const nested = rawConfig?.text_config?.[key];
+  const nested = getNestedTextConfig(rawConfig)?.[key];
   return resolveTokenizerId(direct ?? nested);
 }
 
 function resolveConfigTokenIds(rawConfig, key) {
   const direct = rawConfig?.[key];
-  const nested = rawConfig?.text_config?.[key];
+  const nested = getNestedTextConfig(rawConfig)?.[key];
   return resolveTokenizerIds(direct ?? nested);
 }
 
 function resolveMoEConfigNumber(rawConfig, ...keys) {
+  const nestedTextConfig = getNestedTextConfig(rawConfig);
   for (const key of keys) {
     const direct = rawConfig?.[key];
     if (Number.isFinite(direct) && direct > 0) return Number(direct);
-    const nested = rawConfig?.text_config?.[key];
+    const nested = nestedTextConfig?.[key];
     if (Number.isFinite(nested) && nested > 0) return Number(nested);
   }
   return null;
@@ -317,7 +319,7 @@ function resolveIntermediateSizeFromTensors(architecture, model, tensorLocations
   if (typeof current !== 'number' || !Number.isFinite(current) || current <= 0) {
     return architecture;
   }
-  const modelType = String(rawConfig?.model_type ?? rawConfig?.text_config?.model_type ?? '').toLowerCase();
+  const modelType = String(rawConfig?.model_type ?? getNestedTextConfig(rawConfig)?.model_type ?? '').toLowerCase();
   if (modelType !== 'lfm2') {
     return architecture;
   }
@@ -359,7 +361,7 @@ function resolveMoEExpertFormat(rawConfig, resolvedModelType, quantizationInfo,
   const modelType = String(
     resolvedModelType ??
     rawConfig?.model_type ??
-    rawConfig?.text_config?.model_type ??
+    getNestedTextConfig(rawConfig)?.model_type ??
     ''
   ).toLowerCase();
   if (modelType.includes('gpt_oss') || modelType.includes('gpt-oss') || modelType.includes('gptoss')) {
@@ -725,9 +727,7 @@ export function extractArchitecture(config, ggufConfig) {
 
   // Try HuggingFace config first
   if (config && Object.keys(config).length > 0) {
-    const textConfig = (
-      config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)
-    ) ? config.text_config : null;
+    const textConfig = getNestedTextConfig(config);
     const fromConfig = (...keys) => {
       const values = [];
       for (const key of keys) {
@@ -860,6 +860,19 @@ export function extractArchitecture(config, ggufConfig) {
   throw new Error('Missing model config: cannot extract architecture');
 }
 
+function getNestedTextConfig(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return null;
+  }
+  if (config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)) {
+    return config.text_config;
+  }
+  if (config.language_config && typeof config.language_config === 'object' && !Array.isArray(config.language_config)) {
+    return config.language_config;
+  }
+  return null;
+}
+
 
 export function buildTensorMap(tensors, shardSize) {
   if (!shardSize || shardSize <= 0) {

package/src/converter/tokenizer-utils.js

@@ -1,4 +1,5 @@
 export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
+  const nestedTextConfig = getNestedTextConfig(config);
   const candidateSources = [
     tokenizer?.eosTokenId,
     tokenizer?.eos_token_id,
@@ -7,9 +8,9 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
     tokenizerJson?.special_tokens?.eos,
     tokenizerJson?.special_tokens?.eos_token_id,
     config?.eos_token_id,
-    config?.text_config?.eos_token_id,
+    nestedTextConfig?.eos_token_id,
     config?.eos_token_ids,
-    config?.text_config?.eos_token_ids,
+    nestedTextConfig?.eos_token_ids,
   ];
 
   for (const candidate of candidateSources) {
@@ -23,7 +24,7 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
     tokenizerJson?.specialTokens?.eos_token,
     tokenizerJson?.special_tokens?.eos_token,
     config?.eos_token,
-    config?.text_config?.eos_token,
+    nestedTextConfig?.eos_token,
   ];
 
   for (const candidate of eosTokenStringCandidates) {
@@ -48,6 +49,19 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
   throw new Error('Missing eos_token_id. Provide eos_token_id in config or tokenizer metadata.');
 }
 
+function getNestedTextConfig(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return null;
+  }
+  if (config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)) {
+    return config.text_config;
+  }
+  if (config.language_config && typeof config.language_config === 'object' && !Array.isArray(config.language_config)) {
+    return config.language_config;
+  }
+  return null;
+}
+
 function normalizeEosTokenId(value) {
   if (Array.isArray(value)) {
     if (value.length === 0 || value.some((id) => typeof id !== 'number')) {

package/src/formats/rdrr/validation.js

@@ -1,4 +1,5 @@
 import { validateTensorConfigConsistency } from './tensor-config-validator.js';
+import { validateManifestExecutionContract } from '../../config/execution-contract-check.js';
 
 export function validateManifest(manifest) {
   const errors = [];
@@ -196,5 +197,17 @@ export function validateManifest(manifest) {
     }
   }
 
+  if (!isDiffusion && !isEnergy && errors.length === 0) {
+    try {
+      const executionContract = validateManifestExecutionContract(manifest);
+      for (const error of executionContract.errors) {
+        errors.push(error);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[ExecutionContract] ${message}`);
+    }
+  }
+
   return { valid: errors.length === 0, errors, warnings };
 }

package/src/index-browser.d.ts

@@ -1,4 +1,5 @@
 export declare const DOPPLER_VERSION: string;
+export { doppler } from './client/doppler-api.js';
 
 export {
   DopplerLoader,

package/src/index-browser.js

@@ -1,4 +1,5 @@
 export const DOPPLER_VERSION = '0.1.0';
+export { doppler } from './client/doppler-api.js';
 
 // Core loaders
 export {

package/src/index.d.ts

@@ -1,4 +1,5 @@
 export declare const DOPPLER_VERSION: string;
+export { doppler } from './client/doppler-api.js';
 
 // Core loaders
 export {

package/src/index.js

@@ -1,4 +1,5 @@
 export const DOPPLER_VERSION = '0.1.0';
+export { doppler } from './client/doppler-api.js';
 
 // Core loaders
 export {