nexus-ai-pro 0.2.0

package/dist/models/registry.js

@@ -0,0 +1,43 @@
+import { KNOWN_MODELS, MODEL_ALIASES, resolveProvider } from '../types/providers.js';
+export function resolveModelAlias(model, aliases = {}) {
+    return aliases[model] || MODEL_ALIASES[model] || model;
+}
+export function getModelRegistry(config) {
+    return {
+        ...(config?.models?.includeDefaults === false ? {} : KNOWN_MODELS),
+        ...(config?.models?.registry || {}),
+    };
+}
+export function getModelAliases(config) {
+    return {
+        ...MODEL_ALIASES,
+        ...(config?.models?.aliases || {}),
+    };
+}
+export function resolveModel(model, config) {
+    const aliases = getModelAliases(config);
+    const registry = getModelRegistry(config);
+    const resolved = resolveModelAlias(model, aliases);
+    const normalized = resolved.startsWith('ollama/') ? resolved.slice(7) : resolved;
+    return {
+        requestedModel: model,
+        model: resolved,
+        providerName: resolveProvider(resolved) || (resolved.includes('/') ? resolved.split('/')[0] : null),
+        capabilities: registry[resolved] || registry[normalized],
+    };
+}
+export function listKnownModels(config) {
+    return Object.keys(getModelRegistry(config)).sort();
+}
+export function listModelsForProvider(providerName, config) {
+    const registry = getModelRegistry(config);
+    return Object.entries(registry)
+        .filter(([model, capabilities]) => {
+        return capabilities.provider === providerName || resolveProvider(model) === providerName;
+    })
+        .map(([model]) => model)
+        .sort();
+}
+export function getModelCapabilities(model, config) {
+    return resolveModel(model, config).capabilities;
+}

package/dist/next/route-handler.d.ts

@@ -0,0 +1,6 @@
+import type { NexusAI } from '../core/nexus.js';
+export interface NexusRouteHandlerOptions {
+    ai: NexusAI;
+    stream?: boolean;
+}
+export declare function createNexusRouteHandler(options: NexusRouteHandlerOptions): (request: Request) => Promise<Response>;

package/dist/next/route-handler.js

@@ -0,0 +1,35 @@
+export function createNexusRouteHandler(options) {
+    return async function POST(request) {
+        const body = await request.json();
+        if (options.stream || body.stream) {
+            const stream = options.ai.stream({ ...body, stream: true });
+            const encoder = new TextEncoder();
+            return new Response(new ReadableStream({
+                async start(controller) {
+                    try {
+                        for await (const chunk of stream) {
+                            controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+                        }
+                        controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+                        controller.close();
+                    }
+                    catch (error) {
+                        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', error: error instanceof Error ? error.message : String(error) })}\n\n`));
+                        controller.close();
+                    }
+                },
+                cancel() {
+                    stream.abort();
+                },
+            }), {
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache, no-transform',
+                    Connection: 'keep-alive',
+                },
+            });
+        }
+        const response = await options.ai.complete(body);
+        return Response.json(response);
+    };
+}

package/dist/ops/audit-logger.d.ts

@@ -0,0 +1,6 @@
+import type { AuditLogConfig, AuditLogEvent } from '../types/config.js';
+export declare class AuditLogger {
+    private config?;
+    constructor(config?: AuditLogConfig | undefined);
+    log(event: AuditLogEvent): Promise<void>;
+}

package/dist/ops/audit-logger.js

@@ -0,0 +1,19 @@
+export class AuditLogger {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async log(event) {
+        if (!this.config?.enabled)
+            return;
+        const safeEvent = {
+            ...event,
+            timestamp: event.timestamp || new Date().toISOString(),
+        };
+        if (this.config.sink) {
+            await this.config.sink(safeEvent);
+            return;
+        }
+        console.info('[nexus-ai-pro:audit]', JSON.stringify(safeEvent));
+    }
+}

package/dist/ops/health.d.ts

@@ -0,0 +1,29 @@
+export interface ProviderHealthSnapshot {
+    providerName: string;
+    healthy: boolean;
+    successes: number;
+    failures: number;
+    consecutiveFailures: number;
+    avgLatencyMs: number;
+    lastError?: string;
+    lastCheckedAt?: string;
+    score: number;
+}
+export interface HealthConfig {
+    enabled?: boolean;
+    failureThreshold?: number;
+    latencyHalfLife?: number;
+    minScore?: number;
+}
+export declare class ProviderHealthMonitor {
+    private config;
+    private states;
+    constructor(config?: HealthConfig);
+    recordSuccess(providerName: string, latencyMs: number): void;
+    recordFailure(providerName: string, error: unknown): void;
+    snapshot(providerName?: string): ProviderHealthSnapshot[];
+    score(providerName: string): number;
+    isHealthy(providerName: string): boolean;
+    private snapshotOne;
+    private state;
+}

package/dist/ops/health.js

@@ -0,0 +1,69 @@
+export class ProviderHealthMonitor {
+    config;
+    states = new Map();
+    constructor(config = {}) {
+        this.config = config;
+    }
+    recordSuccess(providerName, latencyMs) {
+        if (!this.config.enabled)
+            return;
+        const state = this.state(providerName);
+        state.successes += 1;
+        state.consecutiveFailures = 0;
+        state.avgLatencyMs = state.avgLatencyMs
+            ? state.avgLatencyMs * 0.7 + latencyMs * 0.3
+            : latencyMs;
+        state.lastCheckedAt = new Date().toISOString();
+    }
+    recordFailure(providerName, error) {
+        if (!this.config.enabled)
+            return;
+        const state = this.state(providerName);
+        state.failures += 1;
+        state.consecutiveFailures += 1;
+        state.lastError = error instanceof Error ? error.message : String(error);
+        state.lastCheckedAt = new Date().toISOString();
+    }
+    snapshot(providerName) {
+        const names = providerName ? [providerName] : [...this.states.keys()];
+        return names.map((name) => this.snapshotOne(name));
+    }
+    score(providerName) {
+        return this.snapshotOne(providerName).score;
+    }
+    isHealthy(providerName) {
+        return this.snapshotOne(providerName).healthy;
+    }
+    snapshotOne(providerName) {
+        const state = this.state(providerName);
+        const failureThreshold = this.config.failureThreshold || 3;
+        const failurePenalty = Math.min(60, state.consecutiveFailures * 20);
+        const latencyPenalty = Math.min(30, state.avgLatencyMs / 1000);
+        const score = Math.max(0, 100 - failurePenalty - latencyPenalty);
+        const minScore = this.config.minScore ?? 20;
+        return {
+            providerName,
+            healthy: state.consecutiveFailures < failureThreshold && score >= minScore,
+            successes: state.successes,
+            failures: state.failures,
+            consecutiveFailures: state.consecutiveFailures,
+            avgLatencyMs: Math.round(state.avgLatencyMs),
+            lastError: state.lastError,
+            lastCheckedAt: state.lastCheckedAt,
+            score,
+        };
+    }
+    state(providerName) {
+        let state = this.states.get(providerName);
+        if (!state) {
+            state = {
+                successes: 0,
+                failures: 0,
+                consecutiveFailures: 0,
+                avgLatencyMs: 0,
+            };
+            this.states.set(providerName, state);
+        }
+        return state;
+    }
+}

package/dist/ops/metrics.d.ts

@@ -0,0 +1,53 @@
+import type { PipelineTraceStep } from '../pipeline/types.js';
+export interface MetricsSink {
+    increment(name: string, value?: number, labels?: Record<string, string>): void | Promise<void>;
+    observe(name: string, value: number, labels?: Record<string, string>): void | Promise<void>;
+    gauge?(name: string, value: number, labels?: Record<string, string>): void | Promise<void>;
+}
+export interface MetricsConfig {
+    enabled?: boolean;
+    sink?: MetricsSink;
+    prefix?: string;
+    prometheus?: boolean;
+}
+export declare class InMemoryMetrics implements MetricsSink {
+    private counters;
+    private histograms;
+    private gauges;
+    increment(name: string, value?: number, labels?: Record<string, string>): void;
+    observe(name: string, value: number, labels?: Record<string, string>): void;
+    gauge(name: string, value: number, labels?: Record<string, string>): void;
+    snapshot(): Record<string, unknown>;
+    toPrometheus(prefix?: string): string;
+    private key;
+}
+export interface OpenTelemetryLikeMeter {
+    createCounter(name: string): {
+        add(value: number, labels?: Record<string, string>): void;
+    };
+    createHistogram(name: string): {
+        record(value: number, labels?: Record<string, string>): void;
+    };
+    createObservableGauge?: (name: string) => unknown;
+}
+export declare class OpenTelemetryMetricsSink implements MetricsSink {
+    private meter;
+    private counters;
+    private histograms;
+    constructor(meter: OpenTelemetryLikeMeter);
+    increment(name: string, value?: number, labels?: Record<string, string>): void;
+    observe(name: string, value: number, labels?: Record<string, string>): void;
+}
+export declare class MetricsCollector {
+    private config;
+    private memory;
+    private sink?;
+    private prefix;
+    constructor(config?: MetricsConfig);
+    recordRequest(labels: Record<string, string>): Promise<void>;
+    recordError(labels: Record<string, string>): Promise<void>;
+    recordResponse(labels: Record<string, string>, latencyMs: number, cost?: number): Promise<void>;
+    recordStep(step: PipelineTraceStep): Promise<void>;
+    snapshot(): Record<string, unknown>;
+    toPrometheus(): string;
+}

package/dist/ops/metrics.js

@@ -0,0 +1,122 @@
+export class InMemoryMetrics {
+    counters = new Map();
+    histograms = new Map();
+    gauges = new Map();
+    increment(name, value = 1, labels = {}) {
+        const key = this.key(name, labels);
+        this.counters.set(key, (this.counters.get(key) || 0) + value);
+    }
+    observe(name, value, labels = {}) {
+        const key = this.key(name, labels);
+        const values = this.histograms.get(key) || [];
+        values.push(value);
+        this.histograms.set(key, values);
+    }
+    gauge(name, value, labels = {}) {
+        this.gauges.set(this.key(name, labels), value);
+    }
+    snapshot() {
+        return {
+            counters: Object.fromEntries(this.counters),
+            histograms: Object.fromEntries([...this.histograms].map(([key, values]) => [key, {
+                    count: values.length,
+                    avg: values.length ? values.reduce((sum, item) => sum + item, 0) / values.length : 0,
+                    max: values.length ? Math.max(...values) : 0,
+                }])),
+            gauges: Object.fromEntries(this.gauges),
+        };
+    }
+    toPrometheus(prefix = 'nexus_ai') {
+        const lines = [];
+        for (const [key, value] of this.counters) {
+            lines.push(`${prefix}_${sanitizeMetric(key)} ${value}`);
+        }
+        for (const [key, values] of this.histograms) {
+            const metric = `${prefix}_${sanitizeMetric(key)}`;
+            const sum = values.reduce((total, value) => total + value, 0);
+            lines.push(`${metric}_count ${values.length}`);
+            lines.push(`${metric}_sum ${sum}`);
+        }
+        for (const [key, value] of this.gauges) {
+            lines.push(`${prefix}_${sanitizeMetric(key)} ${value}`);
+        }
+        return lines.join('\n');
+    }
+    key(name, labels) {
+        const suffix = Object.entries(labels)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, value]) => `${key}=${value}`)
+            .join(',');
+        return suffix ? `${name}{${suffix}}` : name;
+    }
+}
+export class OpenTelemetryMetricsSink {
+    meter;
+    counters = new Map();
+    histograms = new Map();
+    constructor(meter) {
+        this.meter = meter;
+    }
+    increment(name, value = 1, labels) {
+        let counter = this.counters.get(name);
+        if (!counter) {
+            counter = this.meter.createCounter(name);
+            this.counters.set(name, counter);
+        }
+        counter.add(value, labels);
+    }
+    observe(name, value, labels) {
+        let histogram = this.histograms.get(name);
+        if (!histogram) {
+            histogram = this.meter.createHistogram(name);
+            this.histograms.set(name, histogram);
+        }
+        histogram.record(value, labels);
+    }
+}
+export class MetricsCollector {
+    config;
+    memory = new InMemoryMetrics();
+    sink;
+    prefix;
+    constructor(config = {}) {
+        this.config = config;
+        this.sink = config.sink || this.memory;
+        this.prefix = config.prefix || 'nexus_ai';
+    }
+    async recordRequest(labels) {
+        if (!this.config.enabled)
+            return;
+        await this.sink?.increment(`${this.prefix}.requests`, 1, labels);
+    }
+    async recordError(labels) {
+        if (!this.config.enabled)
+            return;
+        await this.sink?.increment(`${this.prefix}.errors`, 1, labels);
+    }
+    async recordResponse(labels, latencyMs, cost) {
+        if (!this.config.enabled)
+            return;
+        await this.sink?.increment(`${this.prefix}.responses`, 1, labels);
+        await this.sink?.observe(`${this.prefix}.latency_ms`, latencyMs, labels);
+        if (cost !== undefined)
+            await this.sink?.observe(`${this.prefix}.estimated_cost`, cost, labels);
+    }
+    async recordStep(step) {
+        if (!this.config.enabled)
+            return;
+        await this.sink?.observe(`${this.prefix}.pipeline_step_ms`, step.durationMs, {
+            step: String(step.name),
+            ok: String(step.ok),
+        });
+    }
+    snapshot() {
+        return this.memory.snapshot();
+    }
+    toPrometheus() {
+        return this.memory.toPrometheus(this.prefix.replace(/\./g, '_'));
+    }
+}
+function sanitizeMetric(value) {
+    return value.replace(/[^a-zA-Z0-9_]/g, '_').replace(/_+/g, '_');
+}

package/dist/ops/otel-tracing.d.ts

@@ -0,0 +1,20 @@
+import type { PipelineTrace } from '../pipeline/types.js';
+export interface OpenTelemetryLikeSpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    recordException?(error: Error): void;
+    setStatus?(status: {
+        code: number;
+        message?: string;
+    }): void;
+    end(endTime?: Date): void;
+}
+export interface OpenTelemetryLikeTracer {
+    startSpan(name: string, options?: Record<string, unknown>): OpenTelemetryLikeSpan;
+}
+export declare class OpenTelemetryTraceExporter {
+    private tracer;
+    private spanPrefix;
+    constructor(tracer: OpenTelemetryLikeTracer, spanPrefix?: string);
+    exportTrace(trace: PipelineTrace, attributes?: Record<string, string | number | boolean>): void;
+    private exportStep;
+}

package/dist/ops/otel-tracing.js

@@ -0,0 +1,50 @@
+export class OpenTelemetryTraceExporter {
+    tracer;
+    spanPrefix;
+    constructor(tracer, spanPrefix = 'nexus-ai-pro') {
+        this.tracer = tracer;
+        this.spanPrefix = spanPrefix;
+    }
+    exportTrace(trace, attributes = {}) {
+        const root = this.tracer.startSpan(`${this.spanPrefix}.pipeline`, {
+            startTime: new Date(trace.startedAt),
+        });
+        for (const [key, value] of Object.entries(attributes)) {
+            root.setAttribute(key, value);
+        }
+        if (trace.durationMs !== undefined)
+            root.setAttribute('pipeline.duration_ms', trace.durationMs);
+        if (trace.requestId)
+            root.setAttribute('request.id', trace.requestId);
+        for (const step of trace.steps) {
+            this.exportStep(step, attributes);
+        }
+        root.end(trace.endedAt ? new Date(trace.endedAt) : undefined);
+    }
+    exportStep(step, attributes) {
+        const span = this.tracer.startSpan(`${this.spanPrefix}.${step.name}`, {
+            startTime: new Date(step.startedAt),
+        });
+        for (const [key, value] of Object.entries(attributes)) {
+            span.setAttribute(key, value);
+        }
+        span.setAttribute('pipeline.step', String(step.name));
+        span.setAttribute('pipeline.step.ok', step.ok);
+        span.setAttribute('pipeline.step.duration_ms', step.durationMs);
+        if (step.metadata) {
+            for (const [key, value] of Object.entries(step.metadata)) {
+                if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                    span.setAttribute(`pipeline.step.${key}`, value);
+                }
+            }
+        }
+        if (step.error) {
+            span.recordException?.(new Error(step.error));
+            span.setStatus?.({ code: 2, message: step.error });
+        }
+        else {
+            span.setStatus?.({ code: 1 });
+        }
+        span.end(new Date(step.endedAt));
+    }
+}

package/dist/ops/rate-limiter.d.ts

@@ -0,0 +1,11 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { RateLimitConfig } from '../types/config.js';
+export declare class NexusRateLimitError extends Error {
+    key: string;
+    constructor(key: string);
+}
+export declare class RateLimiter {
+    private buckets;
+    check(request: CompletionRequest, config?: RateLimitConfig): void;
+    private getKey;
+}

package/dist/ops/rate-limiter.js

@@ -0,0 +1,33 @@
+export class NexusRateLimitError extends Error {
+    key;
+    constructor(key) {
+        super(`NexusAI rate limit exceeded for ${key}`);
+        this.key = key;
+        this.name = 'NexusRateLimitError';
+    }
+}
+export class RateLimiter {
+    buckets = new Map();
+    check(request, config) {
+        if (!config?.enabled)
+            return;
+        const key = this.getKey(request, config);
+        const now = Date.now();
+        const bucket = this.buckets.get(key);
+        if (!bucket || bucket.resetAt <= now) {
+            this.buckets.set(key, { count: 1, resetAt: now + config.windowMs });
+            return;
+        }
+        bucket.count += 1;
+        if (bucket.count > config.maxRequests) {
+            throw new NexusRateLimitError(key);
+        }
+    }
+    getKey(request, config) {
+        if (config.key === 'model')
+            return `model:${request.model}`;
+        if (config.key === 'global')
+            return 'global';
+        return `user:${request.userId || 'anonymous'}`;
+    }
+}

package/dist/optimizer/budget.d.ts

@@ -0,0 +1,19 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { BudgetConfig } from '../types/optimizer.js';
+import { Tokenizer } from '../utils/tokenizer.js';
+export declare class TokenBudgetError extends Error {
+    tokens: number;
+    maxTokens: number;
+    constructor(tokens: number, maxTokens: number);
+}
+export declare class BudgetEnforcer {
+    private tokenizer;
+    constructor(tokenizer?: Tokenizer);
+    check(request: CompletionRequest, config?: BudgetConfig): {
+        warnings: string[];
+        exceeded: boolean;
+        tokens: number;
+    };
+    enforce(request: CompletionRequest, config?: BudgetConfig): CompletionRequest;
+    private truncateToBudget;
+}

package/dist/optimizer/budget.js

@@ -0,0 +1,88 @@
+import { Tokenizer } from '../utils/tokenizer.js';
+export class TokenBudgetError extends Error {
+    tokens;
+    maxTokens;
+    constructor(tokens, maxTokens) {
+        super(`Token budget exceeded: ${tokens} tokens > ${maxTokens} max tokens`);
+        this.tokens = tokens;
+        this.maxTokens = maxTokens;
+        this.name = 'TokenBudgetError';
+    }
+}
+export class BudgetEnforcer {
+    tokenizer;
+    constructor(tokenizer = new Tokenizer()) {
+        this.tokenizer = tokenizer;
+    }
+    check(request, config = {}) {
+        if (config.enabled === false || !config.maxInputTokens) {
+            return { warnings: [], exceeded: false, tokens: this.tokenizer.estimateRequestTokens(request) };
+        }
+        const tokens = this.tokenizer.estimateRequestTokens(request);
+        const warnings = [];
+        const warnAt = config.warnAt ?? 0.8;
+        if (tokens >= config.maxInputTokens * warnAt) {
+            warnings.push(`Token usage is at ${Math.round((tokens / config.maxInputTokens) * 100)}% of budget`);
+        }
+        return {
+            warnings,
+            exceeded: tokens > config.maxInputTokens,
+            tokens,
+        };
+    }
+    enforce(request, config = {}) {
+        if (config.enabled === false || !config.maxInputTokens)
+            return request;
+        const status = this.check(request, config);
+        if (!status.exceeded)
+            return request;
+        const action = config.onExceeded || 'error';
+        if (action === 'allow' || action === 'densify')
+            return request;
+        if (action === 'error')
+            throw new TokenBudgetError(status.tokens, config.maxInputTokens);
+        if (action === 'truncate')
+            return this.truncateToBudget(request, config.maxInputTokens);
+        return request;
+    }
+    truncateToBudget(request, maxTokens) {
+        const next = {
+            ...request,
+            messages: [...request.messages],
+        };
+        while (this.tokenizer.estimateRequestTokens(next) > maxTokens && next.messages.length > 0) {
+            const firstUserIndex = next.messages.findIndex((message) => message.role !== 'system');
+            const indexToTrim = firstUserIndex >= 0 ? firstUserIndex : 0;
+            const message = next.messages[indexToTrim];
+            if (typeof message.content === 'string') {
+                if (message.content.length < 200) {
+                    next.messages.splice(indexToTrim, 1);
+                }
+                else {
+                    next.messages[indexToTrim] = {
+                        ...message,
+                        content: message.content.slice(Math.floor(message.content.length * 0.25)),
+                    };
+                }
+            }
+            else {
+                const textPartIndex = message.content.findIndex((part) => part.type === 'text');
+                if (textPartIndex < 0) {
+                    next.messages.splice(indexToTrim, 1);
+                }
+                else {
+                    const part = message.content[textPartIndex];
+                    if (part.type === 'text') {
+                        const content = [...message.content];
+                        content[textPartIndex] = {
+                            ...part,
+                            text: part.text.length < 200 ? '' : part.text.slice(Math.floor(part.text.length * 0.25)),
+                        };
+                        next.messages[indexToTrim] = { ...message, content };
+                    }
+                }
+            }
+        }
+        return next;
+    }
+}

package/dist/optimizer/cost.d.ts

@@ -0,0 +1,13 @@
+import type { NexusAIConfig } from '../types/config.js';
+import type { CostEstimate } from '../types/planning.js';
+export interface CostEstimateInput {
+    model: string;
+    inputTokens: number;
+    outputTokens?: number;
+    config?: Pick<NexusAIConfig, 'models'>;
+}
+export declare class CostBudgetError extends Error {
+    constructor(message: string);
+}
+export declare function estimateCost(input: CostEstimateInput): CostEstimate;
+export declare function assertWithinCostBudget(estimate: CostEstimate, maxEstimatedCost?: number): void;

package/dist/optimizer/cost.js

@@ -0,0 +1,31 @@
+import { resolveModel } from '../models/registry.js';
+export class CostBudgetError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CostBudgetError';
+    }
+}
+export function estimateCost(input) {
+    const resolved = resolveModel(input.model, input.config);
+    const caps = resolved.capabilities;
+    const outputTokens = input.outputTokens ?? 0;
+    const inputCost = caps ? input.inputTokens / 1000 * caps.costPer1kInput : 0;
+    const outputCost = caps ? outputTokens / 1000 * caps.costPer1kOutput : 0;
+    const totalCost = inputCost + outputCost;
+    return {
+        model: resolved.model,
+        inputTokens: input.inputTokens,
+        outputTokens,
+        inputCost,
+        outputCost,
+        totalCost,
+        formatted: `$${totalCost.toFixed(4)}`,
+    };
+}
+export function assertWithinCostBudget(estimate, maxEstimatedCost) {
+    if (maxEstimatedCost === undefined)
+        return;
+    if (estimate.totalCost > maxEstimatedCost) {
+        throw new CostBudgetError(`Estimated cost ${estimate.formatted} exceeds maxEstimatedCost $${maxEstimatedCost.toFixed(4)}`);
+    }
+}

package/dist/optimizer/densifier.d.ts

@@ -0,0 +1,10 @@
+import type { CompletionRequest } from '../types/messages.js';
+import type { DensificationConfig } from '../types/optimizer.js';
+export declare class PromptDensifier {
+    densifyRequest(request: CompletionRequest, config?: DensificationConfig): {
+        request: CompletionRequest;
+        techniques: string[];
+    };
+    densifyText(text: string, techniques: string[], applied: Set<string>, config: DensificationConfig): string;
+    private splitCodeBlocks;
+}