qlogicagent 0.2.1 → 0.4.0

package/dist/skills/memory-store.d.ts

@@ -1,66 +0,0 @@
-export declare const MEMORY_ENTRY_DELIMITER = "\n\u00A7\n";
-export declare const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
-export declare const DEFAULT_USER_CHAR_LIMIT = 1375;
-export type MemoryStoreTarget = "memory" | "user";
-export interface MemoryStoreResult {
-    ok: boolean;
-    message: string;
-    target: MemoryStoreTarget;
-    entries: readonly string[];
-    entryCount: number;
-    usage: string;
-    errorCode?: string;
-}
-export interface MemoryStoreOptions {
-    memoryCharLimit?: number;
-    userCharLimit?: number;
-}
-export interface MemoryStoreSerialized {
-    memory: string;
-    user: string;
-}
-export declare class MemoryStore {
-    private memoryEntries;
-    private userEntries;
-    private frozenSnapshot;
-    private snapshotFrozen;
-    private readonly memoryCharLimit;
-    private readonly userCharLimit;
-    constructor(options?: MemoryStoreOptions);
-    /**
-     * Load from serialized form (e.g. from PG or filesystem).
-     * Deduplicates entries on load.
-     */
-    loadFromSerialized(data: Partial<MemoryStoreSerialized>): void;
-    /**
-     * Serialize current live state for persistence.
-     */
-    serialize(): MemoryStoreSerialized;
-    /**
-     * Freeze current entries for system prompt injection.
-     * Call once at session start. After freezing, mutations update
-     * live state but NOT the system prompt block.
-     */
-    freezeSnapshot(): void;
-    /**
-     * Get frozen system prompt block for the given target.
-     * Returns empty string if no entries or not yet frozen.
-     */
-    getSystemPromptBlock(target: MemoryStoreTarget): string;
-    add(target: MemoryStoreTarget, content: string): MemoryStoreResult;
-    replace(target: MemoryStoreTarget, oldText: string, newContent: string): MemoryStoreResult;
-    remove(target: MemoryStoreTarget, oldText: string): MemoryStoreResult;
-    getEntries(target: MemoryStoreTarget): readonly string[];
-    getUsage(target: MemoryStoreTarget): {
-        used: number;
-        limit: number;
-        percent: number;
-    };
-    isEmpty(): boolean;
-    private entriesFor;
-    private charLimitFor;
-    private formatUsage;
-    private renderBlock;
-    private successResult;
-    private errorResult;
-}

package/dist/skills/memory-store.js

@@ -1,228 +0,0 @@
-// ============================================================
-// Memory Store — character-bounded local memory for agent notes.
-//
-// Inspired by Hermes' MemoryStore design:
-// - Two targets: "memory" (agent notes) + "user" (user profile)
-// - § delimiter between entries
-// - Frozen snapshot for system prompt (KV cache stability)
-// - Exact duplicate rejection
-// - Content safety scanning
-// - Pure in-memory; persistence is the consumer's responsibility.
-// ============================================================
-import { isMemoryContentSafe } from "./memory-tool.js";
-// ── Constants ───────────────────────────────────────────────
-export const MEMORY_ENTRY_DELIMITER = "\n§\n";
-export const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
-export const DEFAULT_USER_CHAR_LIMIT = 1375;
-// ── MemoryStore class ───────────────────────────────────────
-export class MemoryStore {
-    memoryEntries = [];
-    userEntries = [];
-    frozenSnapshot = { memory: "", user: "" };
-    snapshotFrozen = false;
-    memoryCharLimit;
-    userCharLimit;
-    constructor(options) {
-        this.memoryCharLimit = options?.memoryCharLimit ?? DEFAULT_MEMORY_CHAR_LIMIT;
-        this.userCharLimit = options?.userCharLimit ?? DEFAULT_USER_CHAR_LIMIT;
-    }
-    // ── Load / Serialize ────────────────────────────────────
-    /**
-     * Load from serialized form (e.g. from PG or filesystem).
-     * Deduplicates entries on load.
-     */
-    loadFromSerialized(data) {
-        this.memoryEntries = deduplicateEntries(parseEntries(data.memory ?? ""));
-        this.userEntries = deduplicateEntries(parseEntries(data.user ?? ""));
-    }
-    /**
-     * Serialize current live state for persistence.
-     */
-    serialize() {
-        return {
-            memory: this.memoryEntries.join(MEMORY_ENTRY_DELIMITER),
-            user: this.userEntries.join(MEMORY_ENTRY_DELIMITER),
-        };
-    }
-    // ── Snapshot (frozen for system prompt) ─────────────────
-    /**
-     * Freeze current entries for system prompt injection.
-     * Call once at session start. After freezing, mutations update
-     * live state but NOT the system prompt block.
-     */
-    freezeSnapshot() {
-        this.frozenSnapshot = {
-            memory: this.renderBlock("memory", this.memoryEntries),
-            user: this.renderBlock("user", this.userEntries),
-        };
-        this.snapshotFrozen = true;
-    }
-    /**
-     * Get frozen system prompt block for the given target.
-     * Returns empty string if no entries or not yet frozen.
-     */
-    getSystemPromptBlock(target) {
-        if (!this.snapshotFrozen) {
-            // Auto-freeze on first access
-            this.freezeSnapshot();
-        }
-        return this.frozenSnapshot[target];
-    }
-    // ── Mutations ───────────────────────────────────────────
-    add(target, content) {
-        const trimmed = content.trim();
-        if (!trimmed) {
-            return this.errorResult(target, "Content cannot be empty.", "empty_content");
-        }
-        if (!isMemoryContentSafe(trimmed)) {
-            return this.errorResult(target, "Content rejected: potential injection detected.", "unsafe_content");
-        }
-        const entries = this.entriesFor(target);
-        // Exact duplicate check
-        if (entries.includes(trimmed)) {
-            return this.successResult(target, "Entry already exists (no change).");
-        }
-        // Character budget check
-        const newEntries = [...entries, trimmed];
-        const newTotal = newEntries.join(MEMORY_ENTRY_DELIMITER).length;
-        if (newTotal > this.charLimitFor(target)) {
-            const usage = this.formatUsage(target);
-            return this.errorResult(target, `Memory full (${usage}). Remove old entries first.`, "over_limit");
-        }
-        entries.push(trimmed);
-        return this.successResult(target, "Entry added.");
-    }
-    replace(target, oldText, newContent) {
-        const searchText = oldText.trim();
-        const replacement = newContent.trim();
-        if (!searchText) {
-            return this.errorResult(target, "old_text cannot be empty.", "empty_old_text");
-        }
-        if (!replacement) {
-            return this.errorResult(target, "content cannot be empty.", "empty_content");
-        }
-        if (!isMemoryContentSafe(replacement)) {
-            return this.errorResult(target, "Content rejected: potential injection detected.", "unsafe_content");
-        }
-        const entries = this.entriesFor(target);
-        const matchIndices = entries
-            .map((entry, i) => entry.includes(searchText) ? i : -1)
-            .filter((i) => i >= 0);
-        if (matchIndices.length === 0) {
-            return this.errorResult(target, `No entry contains: "${clipForMessage(searchText)}"`, "not_found");
-        }
-        if (matchIndices.length > 1) {
-            // Check if all matches are identical (harmless duplicate)
-            const unique = new Set(matchIndices.map((i) => entries[i]));
-            if (unique.size > 1) {
-                return this.errorResult(target, `Multiple entries match: "${clipForMessage(searchText)}" (${matchIndices.length} matches). Be more specific.`, "ambiguous_match");
-            }
-        }
-        // Replace first match
-        const matchIndex = matchIndices[0];
-        // Check char limit with replacement
-        const projected = [...entries];
-        projected[matchIndex] = replacement;
-        const projectedTotal = projected.join(MEMORY_ENTRY_DELIMITER).length;
-        if (projectedTotal > this.charLimitFor(target)) {
-            const usage = this.formatUsage(target);
-            return this.errorResult(target, `Replacement would exceed limit (${usage}).`, "over_limit");
-        }
-        entries[matchIndex] = replacement;
-        return this.successResult(target, "Entry replaced.");
-    }
-    remove(target, oldText) {
-        const searchText = oldText.trim();
-        if (!searchText) {
-            return this.errorResult(target, "old_text cannot be empty.", "empty_old_text");
-        }
-        const entries = this.entriesFor(target);
-        const matchIndices = entries
-            .map((entry, i) => entry.includes(searchText) ? i : -1)
-            .filter((i) => i >= 0);
-        if (matchIndices.length === 0) {
-            return this.errorResult(target, `No entry contains: "${clipForMessage(searchText)}"`, "not_found");
-        }
-        // Remove all matches (safe: if they all contain the substring, remove them all)
-        for (let i = matchIndices.length - 1; i >= 0; i--) {
-            entries.splice(matchIndices[i], 1);
-        }
-        return this.successResult(target, matchIndices.length === 1 ? "Entry removed." : `${matchIndices.length} entries removed.`);
-    }
-    // ── Read-only accessors ─────────────────────────────────
-    getEntries(target) {
-        return this.entriesFor(target);
-    }
-    getUsage(target) {
-        const entries = this.entriesFor(target);
-        const used = entries.length > 0 ? entries.join(MEMORY_ENTRY_DELIMITER).length : 0;
-        const limit = this.charLimitFor(target);
-        return { used, limit, percent: limit > 0 ? Math.round((used / limit) * 100) : 0 };
-    }
-    isEmpty() {
-        return this.memoryEntries.length === 0 && this.userEntries.length === 0;
-    }
-    // ── Private helpers ─────────────────────────────────────
-    entriesFor(target) {
-        return target === "user" ? this.userEntries : this.memoryEntries;
-    }
-    charLimitFor(target) {
-        return target === "user" ? this.userCharLimit : this.memoryCharLimit;
-    }
-    formatUsage(target) {
-        const { used, limit, percent } = this.getUsage(target);
-        return `${percent}% — ${used}/${limit} chars`;
-    }
-    renderBlock(target, entries) {
-        if (entries.length === 0)
-            return "";
-        const label = target === "user" ? "USER PROFILE" : "MEMORY";
-        const usage = this.formatUsage(target);
-        const divider = "══════════════════════════════════════════════════════════";
-        const body = entries.join(MEMORY_ENTRY_DELIMITER);
-        return `${divider}\n${label} (your personal notes) [${usage}]\n${divider}\n${body}`;
-    }
-    successResult(target, message) {
-        const entries = this.entriesFor(target);
-        return {
-            ok: true,
-            message,
-            target,
-            entries,
-            entryCount: entries.length,
-            usage: this.formatUsage(target),
-        };
-    }
-    errorResult(target, message, errorCode) {
-        const entries = this.entriesFor(target);
-        return {
-            ok: false,
-            message,
-            target,
-            entries,
-            entryCount: entries.length,
-            usage: this.formatUsage(target),
-            errorCode,
-        };
-    }
-}
-// ── Utilities ─────────────────────────────────────────────
-function parseEntries(raw) {
-    if (!raw.trim())
-        return [];
-    return raw.split(MEMORY_ENTRY_DELIMITER).map((e) => e.trim()).filter(Boolean);
-}
-function deduplicateEntries(entries) {
-    const seen = new Set();
-    return entries.filter((entry) => {
-        if (seen.has(entry))
-            return false;
-        seen.add(entry);
-        return true;
-    });
-}
-function clipForMessage(text, maxLength = 60) {
-    if (text.length <= maxLength)
-        return text;
-    return `${text.slice(0, maxLength - 1).trimEnd()}…`;
-}

package/dist/skills/memory-tool.d.ts

@@ -1,67 +0,0 @@
-import type { MemoryProvider, MemorySearchResult } from "qlogicagent-runtime-contracts";
-import type { MemoryStore, MemoryStoreTarget } from "./memory-store.js";
-export declare const MEMORY_TOOL_NAME: "memory";
-export declare const MEMORY_TOOL_MAX_CONTENT_LENGTH = 2000;
-export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "search"];
-export type MemoryToolAction = (typeof MEMORY_TOOL_ACTIONS)[number];
-export declare const MEMORY_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: string[];
-            readonly description: string;
-        };
-        readonly target: {
-            readonly type: "string";
-            readonly enum: readonly ["memory", "user"];
-            readonly description: string;
-        };
-        readonly content: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly old_text: {
-            readonly type: "string";
-            readonly description: "Required for 'replace' and 'remove'. A substring that uniquely identifies the note entry to modify.";
-        };
-        readonly query: {
-            readonly type: "string";
-            readonly description: "Required for 'search'. Natural language query to find relevant memories.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export declare const MEMORY_TOOL_DESCRIPTION: string;
-export declare const MEMORY_TOOL_LABEL = "Memory";
-export declare function isMemoryContentSafe(text: string): boolean;
-export interface MemoryToolParams {
-    action: MemoryToolAction;
-    target?: MemoryStoreTarget;
-    content?: string;
-    old_text?: string;
-    query?: string;
-}
-export interface MemoryToolResult {
-    ok: boolean;
-    message: string;
-    action: string;
-    /** For MD store operations: live entry count */
-    entryCount?: number;
-    /** For MD store operations: usage string */
-    usage?: string;
-    /** For search: qmemory results */
-    results?: MemorySearchResult[];
-    /** Indicates MD store was mutated (consumer should persist) */
-    storeModified?: boolean;
-    errorCode?: string;
-}
-export interface MemoryToolExecutorDeps {
-    /** QMemory provider for semantic search. */
-    provider: MemoryProvider;
-    /** Local MD memory store for notes. */
-    store?: MemoryStore;
-    userId: string;
-    sessionId?: string;
-}
-export declare function executeMemoryTool(params: MemoryToolParams, deps: MemoryToolExecutorDeps): Promise<MemoryToolResult>;

package/dist/skills/memory-tool.js

@@ -1,192 +0,0 @@
-// ============================================================
-// Memory Tool Contract — dual-layer agent memory system.
-//
-// Two independent layers (Hermes-inspired):
-//
-// 1. **MD Memory** (local notes, always in system prompt):
-//    Agent explicitly manages via add / replace / remove.
-//    Character-bounded, no LLM needed, zero-cost.
-//    Frozen snapshot in system prompt for KV cache stability.
-//
-// 2. **QMemory** (semantic long-term memory):
-//    Automatic extraction from every conversation turn.
-//    Agent queries via search action. Vector-based recall.
-//
-// The two layers are independent — no cross-dedup, no sync.
-// MD = curated highlights; QMemory = conversation sediment.
-// ============================================================
-// ── Constants ───────────────────────────────────────────────────
-export const MEMORY_TOOL_NAME = "memory";
-export const MEMORY_TOOL_MAX_CONTENT_LENGTH = 2000;
-export const MEMORY_TOOL_ACTIONS = ["add", "replace", "remove", "search"];
-// ── Tool schema (JSON Schema compatible) ────────────────────
-export const MEMORY_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: MEMORY_TOOL_ACTIONS,
-            description: [
-                "The operation to perform:",
-                "• 'add' — Save a concise note about this user (→ local notes, always visible)",
-                "• 'replace' — Update an existing note by matching a substring (→ local notes)",
-                "• 'remove' — Delete a note by matching a substring (→ local notes)",
-                "• 'search' — Semantic search across long-term memory (→ qmemory)",
-            ].join("\n"),
-        },
-        target: {
-            type: "string",
-            enum: ["memory", "user"],
-            description: [
-                "Which note target to operate on (for add/replace/remove):",
-                "• 'memory' — Your personal observations/notes about this user (default)",
-                "• 'user' — User profile facts (preferences, timezone, etc.)",
-            ].join("\n"),
-        },
-        content: {
-            type: "string",
-            description: [
-                "Required for 'add' and 'replace'. The note content to store.",
-                "Write a concise, factual statement.",
-                "Good: '用户是后端工程师，主要使用 TypeScript 和 Go'",
-                "Good: 'User prefers dark UI themes and minimalist design'",
-                "Bad: '用户说了很多话' (too vague)",
-                "Bad: entire conversation transcripts (too long)",
-            ].join("\n"),
-        },
-        old_text: {
-            type: "string",
-            description: "Required for 'replace' and 'remove'. A substring that uniquely identifies the note entry to modify.",
-        },
-        query: {
-            type: "string",
-            description: "Required for 'search'. Natural language query to find relevant memories.",
-        },
-    },
-    required: ["action"],
-};
-export const MEMORY_TOOL_DESCRIPTION = [
-    "Manage your notes about this user and search long-term memory.",
-    "",
-    "Your notes (add/replace/remove) are always visible in the system prompt.",
-    "Long-term memories are automatically extracted from every conversation",
-    "and searchable via 'search'.",
-    "",
-    "Guidelines:",
-    "- Use 'add' to record important user preferences, facts, or context",
-    "- Use 'replace' to update outdated notes (match by substring)",
-    "- Use 'remove' to delete incorrect notes (match by substring)",
-    "- Use 'search' to recall conversation history and past interactions",
-    "- Keep notes concise — there's a character limit",
-].join("\n");
-export const MEMORY_TOOL_LABEL = "Memory";
-// ── Content safety ──────────────────────────────────────────
-const BLOCKED_PATTERNS = [
-    /ignore\s+(previous|all|above|prior)\s+instructions/i,
-    /you\s+are\s+now\s+/i,
-    /do\s+not\s+tell\s+the\s+user/i,
-    /system\s+prompt\s+override/i,
-];
-export function isMemoryContentSafe(text) {
-    return !BLOCKED_PATTERNS.some((pattern) => pattern.test(text));
-}
-export async function executeMemoryTool(params, deps) {
-    const { action } = params;
-    const target = params.target ?? "memory";
-    // ── MD store operations: add / replace / remove ───────
-    if (action === "add") {
-        if (!deps.store) {
-            return { ok: false, message: "Local memory store is not available.", action, errorCode: "no_store" };
-        }
-        const content = params.content?.trim();
-        if (!content) {
-            return { ok: false, message: "content is required for 'add' action.", action, errorCode: "empty_content" };
-        }
-        if (content.length > MEMORY_TOOL_MAX_CONTENT_LENGTH) {
-            return { ok: false, message: `Content too long (${content.length} chars, max ${MEMORY_TOOL_MAX_CONTENT_LENGTH}).`, action, errorCode: "too_long" };
-        }
-        const result = deps.store.add(target, content);
-        return {
-            ok: result.ok,
-            message: result.ok
-                ? `${result.message} [${result.usage}]`
-                : result.message,
-            action,
-            entryCount: result.entryCount,
-            usage: result.usage,
-            storeModified: result.ok,
-            errorCode: result.errorCode,
-        };
-    }
-    if (action === "replace") {
-        if (!deps.store) {
-            return { ok: false, message: "Local memory store is not available.", action, errorCode: "no_store" };
-        }
-        const oldText = params.old_text?.trim();
-        const content = params.content?.trim();
-        if (!oldText) {
-            return { ok: false, message: "old_text is required for 'replace' action.", action, errorCode: "empty_old_text" };
-        }
-        if (!content) {
-            return { ok: false, message: "content is required for 'replace' action.", action, errorCode: "empty_content" };
-        }
-        if (content.length > MEMORY_TOOL_MAX_CONTENT_LENGTH) {
-            return { ok: false, message: `Content too long (${content.length} chars, max ${MEMORY_TOOL_MAX_CONTENT_LENGTH}).`, action, errorCode: "too_long" };
-        }
-        const result = deps.store.replace(target, oldText, content);
-        return {
-            ok: result.ok,
-            message: result.ok
-                ? `${result.message} [${result.usage}]`
-                : result.message,
-            action,
-            entryCount: result.entryCount,
-            usage: result.usage,
-            storeModified: result.ok,
-            errorCode: result.errorCode,
-        };
-    }
-    if (action === "remove") {
-        if (!deps.store) {
-            return { ok: false, message: "Local memory store is not available.", action, errorCode: "no_store" };
-        }
-        const oldText = params.old_text?.trim();
-        if (!oldText) {
-            return { ok: false, message: "old_text is required for 'remove' action.", action, errorCode: "empty_old_text" };
-        }
-        const result = deps.store.remove(target, oldText);
-        return {
-            ok: result.ok,
-            message: result.ok
-                ? `${result.message} [${result.usage}]`
-                : result.message,
-            action,
-            entryCount: result.entryCount,
-            usage: result.usage,
-            storeModified: result.ok,
-            errorCode: result.errorCode,
-        };
-    }
-    if (action === "search") {
-        const query = params.query?.trim();
-        if (!query) {
-            return { ok: false, message: "query is required for 'search' action.", action, errorCode: "empty_query" };
-        }
-        try {
-            const results = await deps.provider.search(query, deps.userId, { limit: 10 });
-            if (results.length === 0) {
-                return { ok: true, message: "No matching memories found.", action, results: [] };
-            }
-            return {
-                ok: true,
-                message: results.map((r, i) => `${i + 1}. [${r.blockId}] ${r.text}`).join("\n"),
-                action,
-                results,
-            };
-        }
-        catch (error) {
-            return { ok: false, message: `Search failed: ${error instanceof Error ? error.message : String(error)}`, action, errorCode: "search_failed" };
-        }
-    }
-    return { ok: false, message: `Unknown action: ${action}. Use 'add', 'replace', 'remove', or 'search'.`, action, errorCode: "unknown_action" };
-}

package/dist/skills/portable-tool.d.ts

@@ -1,71 +0,0 @@
-/**
- * Content block returned by tool execution.
- * Compatible with OpenAI / Anthropic content array format.
- */
-export interface ToolContentBlock {
-    type: "text" | "image";
-    text?: string;
-    /** base64-encoded image data (only when type === "image") */
-    data?: string;
-    mimeType?: string;
-}
-/**
- * Result of executing a portable tool.
- */
-export interface PortableToolResult {
-    content: ToolContentBlock[];
-    /** Arbitrary structured metadata for the calling runtime. */
-    details?: Record<string, unknown>;
-}
-/**
- * A runtime-agnostic tool definition.
- *
- * @typeParam TParams The expected parameter shape (for TypeScript consumers).
- */
-export interface PortableTool<TParams = Record<string, unknown>> {
-    /** Unique tool name (e.g. "think", "todo", "memory_query"). */
-    name: string;
-    /** Human-readable label. */
-    label: string;
-    /** Tool description shown to the LLM. */
-    description: string;
-    /** JSON Schema object describing the tool's parameters. */
-    parameters: Record<string, unknown>;
-    /**
-     * When true, the tool should NOT appear in the default tool list.
-     * The host injects it only for complex tasks (e.g. multi-step reasoning)
-     * or when explicitly activated via tool_search.
-     * This saves context tokens in simple conversations.
-     */
-    shouldDefer?: boolean;
-    /**
-     * Whether the tool can safely run concurrently with other tools.
-     * When true, the runtime may execute this tool in parallel with others.
-     * Default: false (sequential execution assumed).
-     */
-    isConcurrencySafe?: boolean;
-    /**
-     * Whether the tool only reads state and never mutates anything.
-     * Read-only tools can skip confirmation prompts in strict permission modes.
-     */
-    isReadOnly?: boolean;
-    /**
-     * Brief keyword hint for tool_search to match against
-     * (e.g. "return the final response as structured JSON").
-     */
-    searchHint?: string;
-    /**
-     * Maximum allowed content size in characters for the tool result.
-     * The runtime should truncate/reject results exceeding this.
-     */
-    maxResultSizeChars?: number;
-    /**
-     * Execute the tool.
-     *
-     * @param toolCallId - Unique ID for this tool invocation (for tracing).
-     * @param params     - Parsed parameters matching the JSON Schema.
-     * @param signal     - Optional abort signal.
-     * @returns Tool result with content blocks + optional details.
-     */
-    execute(toolCallId: string, params: TParams, signal?: AbortSignal): Promise<PortableToolResult>;
-}

package/dist/skills/portable-tool.js

@@ -1,14 +0,0 @@
-// ============================================================
-// Portable Tool Contract — runtime-agnostic tool interface.
-//
-// This is the minimal tool definition that any agent runtime
-// (openclaw, Hub, Electron, third-party) can consume. It uses
-// plain JSON Schema objects instead of @sinclair/typebox so
-// there are zero external dependencies.
-//
-// Consumers wrap PortableTool into their own tool system:
-//   - openclaw → AgentTool<TSchema>  (via typebox adapter)
-//   - Hub      → hub-managed tool registration
-//   - Electron → desktop tool host
-// ============================================================
-export {};