monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/context/project-conventions-provider.js

@@ -0,0 +1,19 @@
+/**
+ * ProjectConventionsProvider — loads project-level conventions (e.g. from
+ * CLAUDE.md or a config file) and injects them as a required context section.
+ */
+import { BaseContextProvider } from './context-provider.js';
+export class ProjectConventionsProvider extends BaseContextProvider {
+    loader;
+    name = 'project-conventions';
+    priority = 100;
+    required = true;
+    constructor(loader) {
+        super();
+        this.loader = loader;
+    }
+    async provide(_ctx) {
+        return this.loader();
+    }
+}
+//# sourceMappingURL=project-conventions-provider.js.map

package/packages/@monomind/cli/dist/src/context/prompt-assembler.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PromptAssembler — collects context sections from multiple providers,
+ * prioritises them within a token budget, and concatenates the result
+ * with the base prompt.
+ */
+import type { ContextProvider, RunContext } from './context-provider.js';
+export interface AssemblyConfig {
+    maxTotalTokens?: number;
+    basePromptTokens: number;
+    providers: ContextProvider[];
+}
+export interface AssembledPrompt {
+    content: string;
+    sectionsIncluded: string[];
+    sectionsTruncated: string[];
+    sectionsDropped: string[];
+    totalTokenEstimate: number;
+}
+export declare class PromptAssembler {
+    private readonly maxTotalTokens;
+    private readonly basePromptTokens;
+    private readonly providers;
+    constructor(config: AssemblyConfig);
+    assemble(basePrompt: string, ctx: RunContext): Promise<AssembledPrompt>;
+}
+//# sourceMappingURL=prompt-assembler.d.ts.map

package/packages/@monomind/cli/dist/src/context/prompt-assembler.js

@@ -0,0 +1,93 @@
+/**
+ * PromptAssembler — collects context sections from multiple providers,
+ * prioritises them within a token budget, and concatenates the result
+ * with the base prompt.
+ */
+const DEFAULT_MAX_TOTAL_TOKENS = 6000;
+const CHARS_PER_TOKEN = 4;
+const SECTION_SEPARATOR = '\n\n---\n\n';
+function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateToTokens(text, maxTokens) {
+    const maxChars = maxTokens * CHARS_PER_TOKEN;
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return text.slice(0, maxChars);
+}
+export class PromptAssembler {
+    maxTotalTokens;
+    basePromptTokens;
+    providers;
+    constructor(config) {
+        this.maxTotalTokens = config.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
+        this.basePromptTokens = config.basePromptTokens;
+        this.providers = config.providers;
+    }
+    async assemble(basePrompt, ctx) {
+        // 1. Call all providers concurrently
+        const settled = await Promise.allSettled(this.providers.map(async (p) => {
+            const content = await p.provide(ctx);
+            return {
+                name: p.name,
+                content,
+                tokens: estimateTokens(content),
+                priority: p.priority,
+                required: p.required,
+            };
+        }));
+        // 2. Filter out rejected / empty results
+        const sections = [];
+        for (const result of settled) {
+            if (result.status === 'fulfilled' && result.value.content.length > 0) {
+                sections.push(result.value);
+            }
+        }
+        // 3. Sort by priority descending
+        sections.sort((a, b) => b.priority - a.priority);
+        // 4. Fit within budget
+        const budget = this.maxTotalTokens - this.basePromptTokens;
+        let remaining = budget;
+        const included = [];
+        const truncated = [];
+        const dropped = [];
+        for (const section of sections) {
+            if (section.tokens <= remaining) {
+                // Fits entirely
+                included.push(section);
+                remaining -= section.tokens;
+            }
+            else if (section.required) {
+                // Required but exceeds remaining — truncate to fit
+                const truncatedContent = truncateToTokens(section.content, remaining);
+                included.push({
+                    ...section,
+                    content: truncatedContent,
+                    tokens: estimateTokens(truncatedContent),
+                });
+                truncated.push(section.name);
+                remaining -= estimateTokens(truncatedContent);
+            }
+            else {
+                // Optional and doesn't fit — drop
+                dropped.push(section.name);
+            }
+        }
+        // 5. Build final prompt: context sections first, then base prompt
+        const contextParts = included.map((s) => s.content);
+        const assembled = contextParts.length > 0
+            ? contextParts.join(SECTION_SEPARATOR) +
+                SECTION_SEPARATOR +
+                basePrompt
+            : basePrompt;
+        return {
+            content: assembled,
+            sectionsIncluded: included.map((s) => s.name),
+            sectionsTruncated: truncated,
+            sectionsDropped: dropped,
+            totalTokenEstimate: estimateTokens(assembled),
+        };
+    }
+}
+//# sourceMappingURL=prompt-assembler.js.map

package/packages/@monomind/cli/dist/src/context/task-history-provider.d.ts

@@ -0,0 +1,24 @@
+/**
+ * TaskHistoryProvider — searches memory for previously completed tasks that
+ * are similar to the current one and formats them as markdown context.
+ */
+import { BaseContextProvider, type RunContext } from './context-provider.js';
+export interface SearchResult {
+    metadata: Record<string, unknown>;
+    value: string;
+    score: number;
+}
+export type SearchFn = (query: string, options: {
+    namespace: string;
+    limit: number;
+    minScore: number;
+}) => Promise<SearchResult[]>;
+export declare class TaskHistoryProvider extends BaseContextProvider {
+    private readonly search;
+    readonly name: "task-history";
+    readonly priority = 50;
+    readonly maxTokens = 600;
+    constructor(search: SearchFn);
+    provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=task-history-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/task-history-provider.js

@@ -0,0 +1,32 @@
+/**
+ * TaskHistoryProvider — searches memory for previously completed tasks that
+ * are similar to the current one and formats them as markdown context.
+ */
+import { BaseContextProvider } from './context-provider.js';
+export class TaskHistoryProvider extends BaseContextProvider {
+    search;
+    name = 'task-history';
+    priority = 50;
+    maxTokens = 600;
+    constructor(search) {
+        super();
+        this.search = search;
+    }
+    async provide(ctx) {
+        const results = await this.search(ctx.taskDescription, {
+            namespace: 'tasks',
+            limit: 5,
+            minScore: 0.6,
+        });
+        if (!results || results.length === 0) {
+            return '';
+        }
+        const lines = ['**Similar past tasks:**'];
+        for (const r of results) {
+            const label = r.metadata?.['title'] ?? r.value.slice(0, 80);
+            lines.push(`- (${(r.score * 100).toFixed(0)}%) ${label}`);
+        }
+        return this.truncateToTokens(lines.join('\n'), this.maxTokens);
+    }
+}
+//# sourceMappingURL=task-history-provider.js.map

package/packages/@monomind/cli/dist/src/context/user-preferences-provider.d.ts

@@ -0,0 +1,14 @@
+/**
+ * UserPreferencesProvider — fetches user-level preferences for the active
+ * session and formats them as a bullet list for injection into the prompt.
+ */
+import { BaseContextProvider, type RunContext } from './context-provider.js';
+export type PreferencesGetter = (sessionId: string) => Promise<Record<string, string>>;
+export declare class UserPreferencesProvider extends BaseContextProvider {
+    private readonly getter;
+    readonly name: "user-preferences";
+    readonly priority = 90;
+    constructor(getter: PreferencesGetter);
+    provide(ctx: RunContext): Promise<string>;
+}
+//# sourceMappingURL=user-preferences-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/user-preferences-provider.js

@@ -0,0 +1,27 @@
+/**
+ * UserPreferencesProvider — fetches user-level preferences for the active
+ * session and formats them as a bullet list for injection into the prompt.
+ */
+import { BaseContextProvider } from './context-provider.js';
+export class UserPreferencesProvider extends BaseContextProvider {
+    getter;
+    name = 'user-preferences';
+    priority = 90;
+    constructor(getter) {
+        super();
+        this.getter = getter;
+    }
+    async provide(ctx) {
+        const prefs = await this.getter(ctx.sessionId);
+        const entries = Object.entries(prefs);
+        if (entries.length === 0) {
+            return '';
+        }
+        const lines = ['**User preferences:**'];
+        for (const [key, value] of entries) {
+            lines.push(`- ${key}: ${value}`);
+        }
+        return this.truncateToTokens(lines.join('\n'), this.maxTokens);
+    }
+}
+//# sourceMappingURL=user-preferences-provider.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-reader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * DLQ Reader (Task 37)
+ *
+ * Reads, filters, and purges DLQ entries from JSONL storage.
+ */
+import type { DLQEntry, DLQEntryStatus } from '../../../shared/src/types/dlq.js';
+/** Options for listing DLQ entries */
+export interface DLQListOptions {
+    status?: DLQEntryStatus;
+    toolName?: string;
+    agentId?: string;
+    olderThanDays?: number;
+    limit?: number;
+}
+export declare class DLQReader {
+    private readonly filePath;
+    constructor(filePath: string);
+    /** Read all entries from the JSONL file with a hard size cap.
+     * The DLQ is append-only with no rotation — without this guard a long-running
+     * process can grow the file to GBs and OOM on every list/get/purge call. */
+    private readAll;
+    /** Write all entries back (used for purge) — uses unique tmp filename to avoid concurrent writer collisions */
+    private writeAll;
+    /** List entries with optional filters (defaults to status='pending') */
+    list(opts?: DLQListOptions): DLQEntry[];
+    /** Get a single entry by messageId */
+    get(messageId: string): DLQEntry | null;
+    /** Purge old pending entries (mark as 'purged') */
+    purge(olderThanDays: number): number;
+}
+//# sourceMappingURL=dlq-reader.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-reader.js

@@ -0,0 +1,81 @@
+/**
+ * DLQ Reader (Task 37)
+ *
+ * Reads, filters, and purges DLQ entries from JSONL storage.
+ */
+import { randomUUID } from 'crypto';
+import { existsSync, readFileSync, writeFileSync, renameSync, statSync, unlinkSync } from 'fs';
+import { parseJsonl } from '../utils/parse-jsonl.js';
+export class DLQReader {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /** Read all entries from the JSONL file with a hard size cap.
+     * The DLQ is append-only with no rotation — without this guard a long-running
+     * process can grow the file to GBs and OOM on every list/get/purge call. */
+    readAll() {
+        if (!existsSync(this.filePath))
+            return [];
+        const stat = statSync(this.filePath);
+        if (stat.size > 256 * 1024 * 1024) {
+            throw new Error(`DLQ file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
+        }
+        const raw = readFileSync(this.filePath, 'utf-8');
+        return parseJsonl(raw);
+    }
+    /** Write all entries back (used for purge) — uses unique tmp filename to avoid concurrent writer collisions */
+    writeAll(entries) {
+        const content = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
+        const tmp = `${this.filePath}.${randomUUID()}.tmp`;
+        try {
+            writeFileSync(tmp, content, 'utf-8');
+            renameSync(tmp, this.filePath);
+        }
+        catch (err) {
+            try {
+                unlinkSync(tmp);
+            }
+            catch { /* ignore cleanup failure */ }
+            throw err;
+        }
+    }
+    /** List entries with optional filters (defaults to status='pending') */
+    list(opts = {}) {
+        const status = opts.status ?? 'pending';
+        let entries = this.readAll().filter((e) => e.status === status);
+        if (opts.toolName) {
+            entries = entries.filter((e) => e.toolName === opts.toolName);
+        }
+        if (opts.agentId) {
+            entries = entries.filter((e) => e.agentId === opts.agentId);
+        }
+        if (opts.olderThanDays !== undefined) {
+            const cutoff = Date.now() - opts.olderThanDays * 24 * 60 * 60 * 1000;
+            entries = entries.filter((e) => new Date(e.createdAt).getTime() < cutoff);
+        }
+        if (opts.limit !== undefined) {
+            entries = entries.slice(0, opts.limit);
+        }
+        return entries;
+    }
+    /** Get a single entry by messageId */
+    get(messageId) {
+        return this.readAll().find((e) => e.messageId === messageId) ?? null;
+    }
+    /** Purge old pending entries (mark as 'purged') */
+    purge(olderThanDays) {
+        const entries = this.readAll();
+        const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+        let count = 0;
+        for (const entry of entries) {
+            if (entry.status === 'pending' && new Date(entry.createdAt).getTime() < cutoff) {
+                entry.status = 'purged';
+                count++;
+            }
+        }
+        this.writeAll(entries);
+        return count;
+    }
+}
+//# sourceMappingURL=dlq-reader.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * DLQ Replayer (Task 37)
+ *
+ * Replays dead-letter queue entries by re-invoking the original tool call.
+ *
+ * CONCURRENCY: Uses append-only status records to avoid racing with DLQWriter.enqueue().
+ * A status record `{ _statusFor, status, replayedAt, replayResult }` is appended after
+ * replay. readAll() merges status records into the base entries — the last status wins.
+ * Compaction rewrites the file when status records exceed 20% of total lines.
+ */
+import type { DLQReplayResult } from '../../../shared/src/types/dlq.js';
+/** A function that attempts to call a tool with the original payload */
+export type ToolCaller = (toolName: string, payload: unknown) => Promise<void>;
+export declare class DLQReplayer {
+    private readonly filePath;
+    private readonly toolCaller;
+    constructor(filePath: string, toolCaller: ToolCaller);
+    /** Read all lines, merge status records into entries. Last status wins. */
+    private readAll;
+    /** Append a status-change record — never touches existing lines, safe alongside DLQWriter. */
+    private appendStatus;
+    /** Compact: rewrite file with merged entries only, removing status records. */
+    private compact;
+    /** Replay a single DLQ entry by messageId */
+    replay(messageId: string): Promise<DLQReplayResult>;
+}
+//# sourceMappingURL=dlq-replayer.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.js

@@ -0,0 +1,90 @@
+/**
+ * DLQ Replayer (Task 37)
+ *
+ * Replays dead-letter queue entries by re-invoking the original tool call.
+ *
+ * CONCURRENCY: Uses append-only status records to avoid racing with DLQWriter.enqueue().
+ * A status record `{ _statusFor, status, replayedAt, replayResult }` is appended after
+ * replay. readAll() merges status records into the base entries — the last status wins.
+ * Compaction rewrites the file when status records exceed 20% of total lines.
+ */
+import { appendFileSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs';
+export class DLQReplayer {
+    filePath;
+    toolCaller;
+    constructor(filePath, toolCaller) {
+        this.filePath = filePath;
+        this.toolCaller = toolCaller;
+    }
+    /** Read all lines, merge status records into entries. Last status wins. */
+    readAll() {
+        if (!existsSync(this.filePath))
+            return { entries: [], rawLineCount: 0 };
+        const stat = statSync(this.filePath);
+        if (stat.size > 256 * 1024 * 1024) {
+            throw new Error(`DLQ file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
+        }
+        const raw = readFileSync(this.filePath, 'utf-8').trim();
+        if (!raw)
+            return { entries: [], rawLineCount: 0 };
+        const lines = raw.split('\n').filter(Boolean);
+        const statusMap = new Map();
+        const baseEntries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed._statusFor) {
+                    statusMap.set(parsed._statusFor, parsed);
+                }
+                else {
+                    baseEntries.push(parsed);
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+        const entries = baseEntries.map((e) => {
+            const s = statusMap.get(e.messageId);
+            return s ? { ...e, status: s.status, replayedAt: s.replayedAt, replayResult: s.replayResult } : e;
+        });
+        return { entries, rawLineCount: lines.length };
+    }
+    /** Append a status-change record — never touches existing lines, safe alongside DLQWriter. */
+    appendStatus(record) {
+        appendFileSync(this.filePath, JSON.stringify(record) + '\n', 'utf-8');
+    }
+    /** Compact: rewrite file with merged entries only, removing status records. */
+    compact(entries) {
+        const content = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
+        const tmp = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, content, 'utf-8');
+        renameSync(tmp, this.filePath);
+    }
+    /** Replay a single DLQ entry by messageId */
+    async replay(messageId) {
+        const { entries, rawLineCount } = this.readAll();
+        const entry = entries.find((e) => e.messageId === messageId);
+        if (!entry) {
+            throw new Error(`DLQ entry not found: ${messageId}`);
+        }
+        if (entry.status !== 'pending') {
+            throw new Error(`DLQ entry is not pending: ${messageId} (status=${entry.status})`);
+        }
+        const now = new Date().toISOString();
+        try {
+            await this.toolCaller(entry.toolName, entry.originalPayload);
+            this.appendStatus({ _statusFor: messageId, status: 'replayed', replayedAt: now, replayResult: 'success' });
+            // Compact when status records inflate file by >20%
+            if (rawLineCount > 0 && (rawLineCount - entries.length) / rawLineCount > 0.2) {
+                const merged = entries.map((e) => e.messageId === messageId ? { ...e, status: 'replayed', replayedAt: now, replayResult: 'success' } : e);
+                this.compact(merged);
+            }
+            return { messageId, success: true, replayedAt: now };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            this.appendStatus({ _statusFor: messageId, status: 'pending', replayedAt: now, replayResult: 'failed_again' });
+            return { messageId, success: false, errorMessage, replayedAt: now };
+        }
+    }
+}
+//# sourceMappingURL=dlq-replayer.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-writer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DLQ Writer (Task 37)
+ *
+ * JSONL append-only storage for dead-letter queue entries.
+ */
+import type { DLQEntry, DeliveryAttempt } from '../../../shared/src/types/dlq.js';
+/** Input for enqueue — caller provides these fields */
+export interface EnqueueInput {
+    toolName: string;
+    originalPayload: unknown;
+    deliveryAttempts: DeliveryAttempt[];
+    agentId?: string;
+    swarmId?: string;
+    tags?: string[];
+}
+export declare class DLQWriter {
+    private readonly filePath;
+    constructor(dataDir: string);
+    /** Enqueue a failed message into the DLQ */
+    enqueue(input: EnqueueInput): DLQEntry;
+    /** Get the file path (for reader/replayer) */
+    getFilePath(): string;
+}
+//# sourceMappingURL=dlq-writer.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-writer.js

@@ -0,0 +1,65 @@
+/**
+ * DLQ Writer (Task 37)
+ *
+ * JSONL append-only storage for dead-letter queue entries.
+ */
+import { randomUUID } from 'crypto';
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join, resolve, sep } from 'path';
+export class DLQWriter {
+    filePath;
+    constructor(dataDir) {
+        const resolvedDataDir = resolve(dataDir);
+        const allowedRoot = resolve(process.env.MONOMIND_DATA_DIR ?? process.cwd());
+        if (resolvedDataDir !== allowedRoot && !resolvedDataDir.startsWith(allowedRoot + sep)) {
+            throw new Error(`DLQ dataDir escapes allowed root: ${resolvedDataDir}`);
+        }
+        if (!existsSync(resolvedDataDir)) {
+            mkdirSync(resolvedDataDir, { recursive: true });
+        }
+        this.filePath = join(resolvedDataDir, 'dead-letter-queue.jsonl');
+    }
+    /** Enqueue a failed message into the DLQ */
+    enqueue(input) {
+        const lastAttempt = input.deliveryAttempts[input.deliveryAttempts.length - 1];
+        const firstAttempt = input.deliveryAttempts[0];
+        const entry = {
+            messageId: randomUUID(),
+            toolName: input.toolName,
+            originalPayload: input.originalPayload,
+            deliveryAttempts: input.deliveryAttempts,
+            finalError: lastAttempt?.errorMessage ?? 'unknown',
+            finalErrorType: lastAttempt?.errorType ?? 'unknown',
+            agentId: input.agentId,
+            swarmId: input.swarmId,
+            createdAt: firstAttempt?.attemptedAt ?? new Date().toISOString(),
+            archivedAt: new Date().toISOString(),
+            status: 'pending',
+            tags: input.tags ?? [],
+        };
+        // JSON.stringify can throw on circular references, BigInt, and non-serializable
+        // values. originalPayload is `unknown` (caller-controlled), so a malicious or
+        // malformed input could otherwise crash the writer mid-flight. Fall back to
+        // a sanitized record so the audit trail is preserved.
+        let serialized;
+        try {
+            serialized = JSON.stringify(entry);
+        }
+        catch {
+            serialized = JSON.stringify({
+                messageId: entry.messageId,
+                toolName: entry.toolName,
+                archivedAt: entry.archivedAt,
+                status: 'pending',
+                finalError: 'serialize_failed',
+            });
+        }
+        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
+        return entry;
+    }
+    /** Get the file path (for reader/replayer) */
+    getFilePath() {
+        return this.filePath;
+    }
+}
+//# sourceMappingURL=dlq-writer.js.map

package/packages/@monomind/cli/dist/src/dlq/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * DLQ Module Barrel (Task 37)
+ */
+export { DLQWriter } from './dlq-writer.js';
+export type { EnqueueInput } from './dlq-writer.js';
+export { DLQReader } from './dlq-reader.js';
+export type { DLQListOptions } from './dlq-reader.js';
+export { DLQReplayer } from './dlq-replayer.js';
+export type { ToolCaller } from './dlq-replayer.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/index.js

@@ -0,0 +1,7 @@
+/**
+ * DLQ Module Barrel (Task 37)
+ */
+export { DLQWriter } from './dlq-writer.js';
+export { DLQReader } from './dlq-reader.js';
+export { DLQReplayer } from './dlq-replayer.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/eval/dataset-manager.d.ts

@@ -0,0 +1,33 @@
+import type { EvalDataset, EvalDatasetEntry, EvalTrace } from '../../../shared/src/types/eval.js';
+export interface CreateFromTracesOpts {
+    name: string;
+    description: string;
+    traces: EvalTrace[];
+    agentSlugs?: string[];
+}
+export declare class DatasetManager {
+    private datasetsPath;
+    private entriesPath;
+    constructor(datasetsPath: string, entriesPath: string);
+    /**
+     * Create a dataset from a set of filtered traces.
+     */
+    createFromTraces(opts: CreateFromTracesOpts): EvalDataset;
+    /**
+     * List all datasets.
+     */
+    listDatasets(): EvalDataset[];
+    /**
+     * Get entries for a specific dataset.
+     */
+    getEntries(datasetId: string): EvalDatasetEntry[];
+    /**
+     * Add a single trace to an existing dataset.
+     */
+    addTraceToDataset(datasetId: string, traceId: string): EvalDatasetEntry;
+    /**
+     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
+     */
+    exportToFile(datasetId: string, outputPath: string, allowedRoot?: string): void;
+}
+//# sourceMappingURL=dataset-manager.d.ts.map