@rlynjb/aptkit-core 0.1.0

package/node_modules/@aptkit/prompts/dist/src/recommendation.js

@@ -0,0 +1,110 @@
+export const RECOMMENDATION_PROMPT = `You are a recommendation agent for an ecommerce workspace. You are read-only: you do NOT execute anything. Your recommendations are suggestions for a human to act on.
+
+## Role
+
+Given a diagnosis of why something changed, propose 2-3 concrete actions the merchant can take.
+
+Frame each action in the language of the available action taxonomy:
+
+- scenario: automated, triggered flows such as cart recovery or win-back.
+- segment: define a customer group to target or analyse.
+- campaign: a one-off or scheduled broadcast.
+- voucher: a discount or incentive.
+- experiment: an A/B test to validate a fix before rollout.
+
+## Hard rules
+
+1. Pass project_id: {project_id} to every tool call when a tool accepts project context.
+2. Make at most 4 tool calls. Mostly reason from the diagnosis; optionally check what already exists so you do not duplicate live work.
+3. Check existing scenarios first when scenario tools are available.
+4. Each recommendation MUST set bloomreachFeature to exactly one configured action feature.
+5. Feature-discovery tools may return empty results. Propose new actions grounded in the feature type regardless of whether examples already exist.
+
+## Available feature-discovery tools
+
+Use whichever of these are available in the supplied tool registry:
+
+- list_scenarios, get_scenario
+- list_initiatives, get_initiative_items
+- list_recommendations, get_recommendation
+- list_segmentations
+- list_email_campaigns
+- list_voucher_pools
+- get_frequency_policies
+
+## The diagnosis to act on
+
+{diagnosis}
+
+## How to propose
+
+1. Read the diagnosis: what changed, where, for whom, and why.
+2. Optionally check existing scenarios or segments so your proposals do not duplicate what is already running.
+3. Pick the action feature that best fits.
+4. Write human-readable steps a marketer could follow.
+5. Estimate impact in dollars when the diagnosis provides enough numbers. State the assumption.
+6. Estimate effort, timeToSetUpMinutes, and readResultInDays.
+7. List up to 3 prerequisites with satisfied true or false.
+8. Give a successMetric with a baseline and target.
+9. Order recommendations by predicted impact, highest first.
+10. Mark confidence honestly.
+
+## Output
+
+Return ONLY a JSON array in a json fenced block of at most 3 objects. Do NOT include an id field. The system assigns ids after validation.
+
+Each object must have:
+
+- title: string
+- rationale: string
+- bloomreachFeature: scenario | segment | campaign | voucher | experiment
+- steps: string[]
+- estimatedImpact: string OR { range: string, rangeUsd?: { low: number, high: number }, assumption: string }
+- confidence: high | medium | low
+- effort?: low | medium | high
+- timeToSetUpMinutes?: number
+- readResultInDays?: number
+- prerequisites?: { label: string, satisfied: boolean }[]
+- successMetric?: string
+
+If you cannot propose grounded actions, return [].
+
+## Workspace schema
+
+{schema}`;
+export const recommendationPromptPackage = {
+    id: 'recommendation-agent.default',
+    version: '0.1.0',
+    capabilityId: 'recommendation-agent',
+    description: 'Action recommendation generation from a supported diagnosis and available feature catalog.',
+    system: RECOMMENDATION_PROMPT,
+    variables: [
+        {
+            name: 'schema',
+            description: 'Workspace schema summary with data horizon and available fields.',
+            required: true,
+        },
+        {
+            name: 'project_id',
+            description: 'Host workspace project id for providers that require project context.',
+            required: true,
+        },
+        {
+            name: 'diagnosis',
+            description: 'JSON serialized diagnosis object to act on.',
+            required: true,
+        },
+    ],
+    examples: [
+        {
+            name: 'voucher-dropoff-recommendations',
+            input: {
+                diagnosis: {
+                    conclusion: 'Voucher orders declined after a discount pool expired.',
+                    evidence: ['voucher orders down 32% versus baseline'],
+                },
+            },
+            expectedContains: ['bloomreachFeature', 'successMetric'],
+        },
+    ],
+};

package/node_modules/@aptkit/prompts/dist/src/types.d.ts

@@ -0,0 +1,21 @@
+export type PromptVariable = {
+    name: string;
+    description: string;
+    required: boolean;
+};
+export type PromptExample = {
+    name: string;
+    input: Record<string, unknown>;
+    expectedContains?: string[];
+};
+export type PromptPackage = {
+    id: string;
+    version: string;
+    capabilityId: string;
+    description: string;
+    system: string;
+    compactSystem?: string;
+    variables: PromptVariable[];
+    examples: PromptExample[];
+};
+export declare function renderPromptTemplate(template: string, variables: Record<string, string>): string;

package/node_modules/@aptkit/prompts/dist/src/types.js

@@ -0,0 +1,6 @@
+export function renderPromptTemplate(template, variables) {
+    return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (match, name) => {
+        const value = variables[name];
+        return value === undefined ? match : value;
+    });
+}

package/node_modules/@aptkit/prompts/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@aptkit/prompts",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "README.md",
+    "dist/src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/*.test.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/node_modules/@aptkit/runtime/dist/src/events.d.ts

@@ -0,0 +1,44 @@
+export type CapabilityEvent = {
+    type: 'step';
+    capabilityId: string;
+    role: string;
+    content: string;
+    timestamp: string;
+} | {
+    type: 'tool_call_start';
+    capabilityId: string;
+    toolName: string;
+    args: unknown;
+    timestamp: string;
+} | {
+    type: 'tool_call_end';
+    capabilityId: string;
+    toolName: string;
+    result?: unknown;
+    error?: string;
+    durationMs: number;
+    timestamp: string;
+} | {
+    type: 'model_usage';
+    capabilityId: string;
+    provider: string;
+    model: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    estimated?: boolean;
+    timestamp: string;
+} | {
+    type: 'warning';
+    capabilityId: string;
+    message: string;
+    timestamp: string;
+} | {
+    type: 'error';
+    capabilityId: string;
+    message: string;
+    timestamp: string;
+};
+export type CapabilityTraceSink = {
+    emit(event: CapabilityEvent): void;
+};
+export declare function timestamp(): string;

package/node_modules/@aptkit/runtime/dist/src/events.js

@@ -0,0 +1,3 @@
+export function timestamp() {
+    return new Date().toISOString();
+}

package/node_modules/@aptkit/runtime/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './events.js';
+export * from './json-output.js';
+export * from './model-provider.js';
+export * from './ndjson-stream.js';
+export * from './run-agent-loop.js';
+export * from './usage-ledger.js';

package/node_modules/@aptkit/runtime/dist/src/index.js

@@ -0,0 +1,6 @@
+export * from './events.js';
+export * from './json-output.js';
+export * from './model-provider.js';
+export * from './ndjson-stream.js';
+export * from './run-agent-loop.js';
+export * from './usage-ledger.js';

package/node_modules/@aptkit/runtime/dist/src/json-output.d.ts

@@ -0,0 +1,10 @@
+export type JsonValidation<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+export type JsonValidator<T> = (value: unknown) => JsonValidation<T>;
+export declare function parseAgentJson(text: string): unknown;
+export declare function parseValidatedJson<T>(text: string, validate: JsonValidator<T>): JsonValidation<T>;

package/node_modules/@aptkit/runtime/dist/src/json-output.js

@@ -0,0 +1,32 @@
+export function parseAgentJson(text) {
+    const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidate = (fence ? fence[1] : text).trim();
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        // Fall through to a bounded substring scan.
+    }
+    const objectStart = candidate.indexOf('{');
+    const arrayStart = candidate.indexOf('[');
+    const starts = [objectStart, arrayStart].filter((index) => index >= 0);
+    const start = starts.length > 0 ? Math.min(...starts) : -1;
+    const end = Math.max(candidate.lastIndexOf('}'), candidate.lastIndexOf(']'));
+    if (start >= 0 && end > start) {
+        return JSON.parse(candidate.slice(start, end + 1));
+    }
+    throw new Error('no parseable json in model output');
+}
+export function parseValidatedJson(text, validate) {
+    let parsed;
+    try {
+        parsed = parseAgentJson(text);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return validate(parsed);
+}

package/node_modules/@aptkit/runtime/dist/src/model-provider.d.ts

@@ -0,0 +1,49 @@
+export type ModelTextBlock = {
+    type: 'text';
+    text: string;
+};
+export type ModelToolUseBlock = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+export type ModelToolResultBlock = {
+    type: 'tool_result';
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+};
+export type ModelContentBlock = ModelTextBlock | ModelToolUseBlock;
+export type ModelMessage = {
+    role: 'user' | 'assistant';
+    content: string | ModelContentBlock[] | ModelToolResultBlock[];
+};
+export type ModelTool = {
+    name: string;
+    description?: string;
+    inputSchema: object;
+};
+export type ModelUsage = {
+    inputTokens?: number;
+    outputTokens?: number;
+    estimated?: boolean;
+};
+export type ModelRequest = {
+    system?: string;
+    messages: ModelMessage[];
+    tools?: ModelTool[];
+    maxTokens?: number;
+    temperature?: number;
+    signal?: AbortSignal;
+};
+export type ModelResponse = {
+    content: ModelContentBlock[];
+    usage?: ModelUsage;
+    model?: string;
+};
+export type ModelProvider = {
+    id: string;
+    defaultModel?: string;
+    complete(request: ModelRequest): Promise<ModelResponse>;
+};

package/node_modules/@aptkit/runtime/dist/src/model-provider.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@aptkit/runtime/dist/src/ndjson-stream.d.ts

@@ -0,0 +1,43 @@
+import type { CapabilityEvent } from './events.js';
+export type NdjsonDecodeWarning = {
+    type: 'malformed_line';
+    line: number;
+    raw: string;
+    error: string;
+};
+export type NdjsonDecodeResult<T> = {
+    ok: true;
+    line: number;
+    value: T;
+} | {
+    ok: false;
+    line: number;
+    warning: NdjsonDecodeWarning;
+};
+export type NdjsonDecodeOptions<T> = {
+    validate?: (value: unknown) => value is T;
+    maxWarnings?: number;
+};
+export type NdjsonDecodeSummary<T> = {
+    values: T[];
+    warnings: NdjsonDecodeWarning[];
+};
+export type NdjsonStreamDecodeOptions<T> = NdjsonDecodeOptions<T> & {
+    signal?: AbortSignal;
+};
+/** Serializes one JSON-compatible value as an NDJSON record. */
+export declare function encodeNdjsonRecord(value: unknown): string;
+/** Serializes one capability trace event as an NDJSON record. */
+export declare function encodeCapabilityEvent(event: CapabilityEvent): string;
+/** Runtime guard for the shared capability trace event envelope. */
+export declare function isCapabilityEvent(value: unknown): value is CapabilityEvent;
+/** Decodes one NDJSON line, returning a bounded warning shape instead of throwing. */
+export declare function decodeNdjsonLine<T = unknown>(line: string, lineNumber: number, options?: NdjsonDecodeOptions<T>): NdjsonDecodeResult<T> | null;
+/** Decodes a string containing complete NDJSON records into values and warnings. */
+export declare function decodeNdjsonLines<T = unknown>(input: string, options?: NdjsonDecodeOptions<T>): NdjsonDecodeSummary<T>;
+/** Decodes async NDJSON chunks while preserving partial lines across chunk boundaries. */
+export declare function decodeNdjsonStream<T = unknown>(chunks: AsyncIterable<string | Uint8Array>, options?: NdjsonStreamDecodeOptions<T>): AsyncGenerator<NdjsonDecodeResult<T>>;
+/** Collects decoded async stream records into values and bounded malformed-line warnings. */
+export declare function collectNdjsonStream<T = unknown>(chunks: AsyncIterable<string | Uint8Array>, options?: NdjsonStreamDecodeOptions<T>): Promise<NdjsonDecodeSummary<T>>;
+/** Decodes complete capability event records from a string payload. */
+export declare function decodeCapabilityEventLines(input: string): NdjsonDecodeSummary<CapabilityEvent>;

package/node_modules/@aptkit/runtime/dist/src/ndjson-stream.js

@@ -0,0 +1,128 @@
+const DEFAULT_MAX_WARNINGS = 25;
+/** Serializes one JSON-compatible value as an NDJSON record. */
+export function encodeNdjsonRecord(value) {
+    return `${JSON.stringify(value)}\n`;
+}
+/** Serializes one capability trace event as an NDJSON record. */
+export function encodeCapabilityEvent(event) {
+    return encodeNdjsonRecord(event);
+}
+/** Runtime guard for the shared capability trace event envelope. */
+export function isCapabilityEvent(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.type !== 'string')
+        return false;
+    if (typeof value.capabilityId !== 'string')
+        return false;
+    if (typeof value.timestamp !== 'string')
+        return false;
+    switch (value.type) {
+        case 'step':
+            return typeof value.role === 'string' && typeof value.content === 'string';
+        case 'tool_call_start':
+            return typeof value.toolName === 'string' && 'args' in value;
+        case 'tool_call_end':
+            return typeof value.toolName === 'string' && typeof value.durationMs === 'number';
+        case 'model_usage':
+            return typeof value.provider === 'string' && typeof value.model === 'string';
+        case 'warning':
+        case 'error':
+            return typeof value.message === 'string';
+        default:
+            return false;
+    }
+}
+/** Decodes one NDJSON line, returning a bounded warning shape instead of throwing. */
+export function decodeNdjsonLine(line, lineNumber, options = {}) {
+    const raw = line.trim();
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (options.validate && !options.validate(parsed)) {
+            return malformedLine(lineNumber, line, 'record failed validation');
+        }
+        return { ok: true, line: lineNumber, value: parsed };
+    }
+    catch (error) {
+        return malformedLine(lineNumber, line, error instanceof Error ? error.message : String(error));
+    }
+}
+/** Decodes a string containing complete NDJSON records into values and warnings. */
+export function decodeNdjsonLines(input, options = {}) {
+    const values = [];
+    const warnings = [];
+    const maxWarnings = options.maxWarnings ?? DEFAULT_MAX_WARNINGS;
+    const lines = input.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const result = decodeNdjsonLine(line, index + 1, options);
+        collectDecodeResult(result, values, warnings, maxWarnings);
+    });
+    return { values, warnings };
+}
+/** Decodes async NDJSON chunks while preserving partial lines across chunk boundaries. */
+export async function* decodeNdjsonStream(chunks, options = {}) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lineNumber = 0;
+    for await (const chunk of chunks) {
+        options.signal?.throwIfAborted();
+        buffer += typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+        let newlineIndex = buffer.search(/\r?\n/);
+        while (newlineIndex >= 0) {
+            const line = buffer.slice(0, newlineIndex);
+            const newlineLength = buffer[newlineIndex] === '\r' && buffer[newlineIndex + 1] === '\n' ? 2 : 1;
+            buffer = buffer.slice(newlineIndex + newlineLength);
+            lineNumber += 1;
+            const result = decodeNdjsonLine(line, lineNumber, options);
+            if (result)
+                yield result;
+            options.signal?.throwIfAborted();
+            newlineIndex = buffer.search(/\r?\n/);
+        }
+    }
+    const finalText = decoder.decode();
+    if (finalText)
+        buffer += finalText;
+    if (buffer.trim()) {
+        lineNumber += 1;
+        const result = decodeNdjsonLine(buffer, lineNumber, options);
+        if (result)
+            yield result;
+    }
+}
+/** Collects decoded async stream records into values and bounded malformed-line warnings. */
+export async function collectNdjsonStream(chunks, options = {}) {
+    const values = [];
+    const warnings = [];
+    const maxWarnings = options.maxWarnings ?? DEFAULT_MAX_WARNINGS;
+    for await (const result of decodeNdjsonStream(chunks, options)) {
+        collectDecodeResult(result, values, warnings, maxWarnings);
+    }
+    return { values, warnings };
+}
+/** Decodes complete capability event records from a string payload. */
+export function decodeCapabilityEventLines(input) {
+    return decodeNdjsonLines(input, { validate: isCapabilityEvent });
+}
+function collectDecodeResult(result, values, warnings, maxWarnings) {
+    if (!result)
+        return;
+    if (result.ok) {
+        values.push(result.value);
+        return;
+    }
+    if (warnings.length < maxWarnings)
+        warnings.push(result.warning);
+}
+function malformedLine(line, raw, error) {
+    return {
+        ok: false,
+        line,
+        warning: { type: 'malformed_line', line, raw, error },
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/node_modules/@aptkit/runtime/dist/src/run-agent-loop.d.ts

@@ -0,0 +1,42 @@
+import { type CapabilityTraceSink } from './events.js';
+import type { ModelProvider, ModelTool } from './model-provider.js';
+export type ToolCallRecord = {
+    id: string;
+    capabilityId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+    durationMs?: number;
+    error?: string;
+};
+export type ToolExecutor = {
+    callTool(name: string, args: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        result: unknown;
+        durationMs: number;
+    }>;
+};
+export type AgentRunResult<T = null> = {
+    finalText: string;
+    toolCalls: ToolCallRecord[];
+    parsed: T | null;
+};
+export type RunAgentLoopOptions<T> = {
+    capabilityId: string;
+    model: ModelProvider;
+    tools: ToolExecutor;
+    system: string;
+    userPrompt: string;
+    toolSchemas: ModelTool[];
+    trace?: CapabilityTraceSink;
+    maxTurns?: number;
+    maxTokens?: number;
+    maxToolCalls?: number;
+    synthesisInstruction?: string;
+    signal?: AbortSignal;
+    parseResult?: (finalText: string) => T | null;
+    recoveryPrompt?: (toolCalls: ToolCallRecord[]) => string;
+};
+export declare function buildSynthesisInstruction(middle: string): string;
+export declare function runAgentLoop<T = null>(options: RunAgentLoopOptions<T>): Promise<AgentRunResult<T>>;

package/node_modules/@aptkit/runtime/dist/src/run-agent-loop.js

@@ -0,0 +1,138 @@
+import { timestamp } from './events.js';
+const MAX_TOOL_RESULT_CHARS = 16_000;
+function truncate(value) {
+    if (value.length <= MAX_TOOL_RESULT_CHARS)
+        return value;
+    return `${value.slice(0, MAX_TOOL_RESULT_CHARS)}\n...[truncated]`;
+}
+function textFromContent(content) {
+    return content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+function toolUsesFromContent(content) {
+    return content.filter((block) => block.type === 'tool_use');
+}
+export function buildSynthesisInstruction(middle) {
+    return `You have NO more tool calls available. ${middle} Do not say you need more queries.`;
+}
+export async function runAgentLoop(options) {
+    const { capabilityId, model, tools, system, userPrompt, toolSchemas, trace, maxTurns = 8, maxTokens = 4096, maxToolCalls, synthesisInstruction, signal, } = options;
+    const messages = [{ role: 'user', content: userPrompt }];
+    const toolCalls = [];
+    let finalText = '';
+    for (let turn = 0; turn < maxTurns; turn += 1) {
+        signal?.throwIfAborted();
+        const budgetSpent = maxToolCalls !== undefined && toolCalls.length >= maxToolCalls;
+        const forceFinal = turn === maxTurns - 1 || budgetSpent;
+        const response = await model.complete({
+            system: forceFinal && synthesisInstruction ? `${system}\n\n${synthesisInstruction}` : system,
+            messages,
+            tools: forceFinal ? undefined : toolSchemas,
+            maxTokens,
+            signal,
+        });
+        if (response.usage) {
+            trace?.emit({
+                type: 'model_usage',
+                capabilityId,
+                provider: model.id,
+                model: response.model ?? model.defaultModel ?? 'unknown',
+                inputTokens: response.usage.inputTokens,
+                outputTokens: response.usage.outputTokens,
+                estimated: response.usage.estimated,
+                timestamp: timestamp(),
+            });
+        }
+        messages.push({ role: 'assistant', content: response.content });
+        const text = textFromContent(response.content);
+        if (text) {
+            trace?.emit({ type: 'step', capabilityId, role: 'assistant', content: text, timestamp: timestamp() });
+        }
+        const toolUses = toolUsesFromContent(response.content);
+        if (toolUses.length === 0) {
+            finalText = text;
+            break;
+        }
+        const toolResults = [];
+        for (const toolUse of toolUses) {
+            const toolCall = {
+                id: toolUse.id,
+                capabilityId,
+                toolName: toolUse.name,
+                args: toolUse.input,
+            };
+            trace?.emit({
+                type: 'tool_call_start',
+                capabilityId,
+                toolName: toolUse.name,
+                args: toolUse.input,
+                timestamp: timestamp(),
+            });
+            let isError = false;
+            let resultContent;
+            try {
+                const { result, durationMs } = await tools.callTool(toolUse.name, toolUse.input, { signal });
+                toolCall.result = result;
+                toolCall.durationMs = durationMs;
+                resultContent = truncate(JSON.stringify(result));
+            }
+            catch (error) {
+                isError = true;
+                const message = error instanceof Error ? error.message : String(error);
+                toolCall.error = message;
+                resultContent = truncate(JSON.stringify({ error: message }));
+            }
+            toolCalls.push(toolCall);
+            trace?.emit({
+                type: 'tool_call_end',
+                capabilityId,
+                toolName: toolUse.name,
+                result: toolCall.result,
+                error: toolCall.error,
+                durationMs: toolCall.durationMs ?? 0,
+                timestamp: timestamp(),
+            });
+            toolResults.push({
+                type: 'tool_result',
+                toolUseId: toolUse.id,
+                content: resultContent,
+                ...(isError ? { isError: true } : {}),
+            });
+        }
+        messages.push({ role: 'user', content: toolResults });
+    }
+    let parsed = null;
+    if (options.parseResult) {
+        parsed = options.parseResult(finalText);
+        if (parsed === null && options.recoveryPrompt) {
+            const recoveryText = await runRecoveryTurn(options, options.recoveryPrompt(toolCalls));
+            parsed = recoveryText === null ? null : options.parseResult(recoveryText);
+        }
+    }
+    return { finalText, toolCalls, parsed };
+}
+async function runRecoveryTurn(options, userPrompt) {
+    try {
+        options.signal?.throwIfAborted();
+        const response = await options.model.complete({
+            system: 'You are concluding a completed investigation. Output ONLY the structured answer in the requested shape. Never ask for more data.',
+            messages: [{ role: 'user', content: userPrompt }],
+            maxTokens: 2048,
+            signal: options.signal,
+        });
+        return textFromContent(response.content);
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === 'AbortError')
+            throw error;
+        options.trace?.emit({
+            type: 'warning',
+            capabilityId: options.capabilityId,
+            message: error instanceof Error ? error.message : String(error),
+            timestamp: timestamp(),
+        });
+        return null;
+    }
+}