@beeuni/sdk 0.1.0

package/dist/core/turns/text-scan.js

@@ -0,0 +1,347 @@
+const WS = /\s/;
+const WORD = /\w/;
+function isWs(ch) {
+    return ch !== undefined && WS.test(ch);
+}
+function isLineTerminator(ch) {
+    return ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029';
+}
+function isWord(ch) {
+    return ch !== undefined && WORD.test(ch);
+}
+function fold(s) {
+    let out = '';
+    for (const ch of s)
+        out += ch.length === 1 ? String.fromCharCode(canonical(ch.charCodeAt(0))) : ch;
+    return out;
+}
+function canonical(code) {
+    if (code < 128)
+        return code >= 97 && code <= 122 ? code - 32 : code;
+    const upper = String.fromCharCode(code).toUpperCase();
+    if (upper.length !== 1)
+        return code;
+    const folded = upper.charCodeAt(0);
+    return folded < 128 ? code : folded;
+}
+export function stripTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s[end - 1] === '/')
+        end--;
+    return s.slice(0, end);
+}
+export function stripEdgeSlashes(s) {
+    let start = 0;
+    while (start < s.length && s[start] === '/')
+        start++;
+    return stripTrailingSlashes(s.slice(start));
+}
+export function textBetween(s, open, close) {
+    const o = s.indexOf(open);
+    if (o === -1)
+        return null;
+    const c = s.indexOf(close, o + open.length);
+    return c === -1 ? null : s.slice(o + open.length, c);
+}
+export function tagBodyTrimNewline(s, tag) {
+    let inner = textBetween(s, `<${tag}>`, `</${tag}>`);
+    if (inner === null)
+        return null;
+    if (inner.startsWith('\n'))
+        inner = inner.slice(1);
+    if (inner.endsWith('\n'))
+        inner = inner.slice(0, -1);
+    return inner;
+}
+function openTag(s, tag, from = 0) {
+    const open = s.indexOf(`<${tag}`, from);
+    if (open === -1)
+        return null;
+    const end = s.indexOf('>', open + 1 + tag.length);
+    return end === -1 ? null : { open, end };
+}
+export function tagAttributes(s, tag) {
+    const found = openTag(s, tag);
+    return found ? s.slice(found.open + 1 + tag.length, found.end) : null;
+}
+export function tagBody(s, tag) {
+    const found = openTag(s, tag);
+    if (!found)
+        return null;
+    const close = s.indexOf(`</${tag}>`, found.end + 1);
+    return close === -1 ? null : s.slice(found.end + 1, close);
+}
+export function removeTagBlocks(s, tag) {
+    const closeTag = `</${tag}>`;
+    let out = '';
+    let pos = 0;
+    for (;;) {
+        const found = openTag(s, tag, pos);
+        if (!found)
+            break;
+        const close = s.indexOf(closeTag, found.end + 1);
+        if (close === -1)
+            break;
+        out += s.slice(pos, found.open);
+        pos = close + closeTag.length;
+    }
+    return out + s.slice(pos);
+}
+export function textItems(s, open, close) {
+    const items = [];
+    for (const line of s.split(/[\n\r\u2028\u2029]/)) {
+        let pos = 0;
+        for (;;) {
+            const o = line.indexOf(open, pos);
+            if (o === -1)
+                break;
+            const c = line.indexOf(close, o + open.length);
+            if (c === -1)
+                break;
+            items.push(line.slice(o + open.length, c));
+            pos = c + close.length;
+        }
+    }
+    return items;
+}
+export function jsonTail(s) {
+    const t = s.trimEnd();
+    if (!t.endsWith('}'))
+        return null;
+    let colon = t.indexOf(':');
+    while (colon !== -1) {
+        let j = colon + 1;
+        while (j < t.length && isWs(t[j]))
+            j++;
+        if (t[j] === '{')
+            return t.slice(j);
+        colon = t.indexOf(':', colon + 1);
+    }
+    return null;
+}
+export function hasPhrasePair(s, first, second) {
+    const a = fold(first);
+    const b = fold(second);
+    for (const line of fold(s).split(/[\n\r\u2028\u2029]/)) {
+        const i = line.indexOf(a);
+        if (i === -1)
+            continue;
+        if (line.lastIndexOf(b) >= i + a.length)
+            return true;
+    }
+    return false;
+}
+export function labelledValue(s, labels) {
+    const folded = fold(s);
+    const wanted = labels.map(fold);
+    const n = s.length;
+    const skipWs = (from) => {
+        let i = from;
+        while (i < n && isWs(s[i]))
+            i++;
+        return i;
+    };
+    const nextLineStart = (from) => {
+        for (let i = from; i < n; i++)
+            if (isLineTerminator(s[i]))
+                return i + 1;
+        return -1;
+    };
+    let p = 0;
+    while (p !== -1 && p <= n) {
+        const q = skipWs(p);
+        if (q >= n)
+            return null;
+        const label = wanted.find((l) => folded.startsWith(l, q));
+        if (label !== undefined) {
+            const k = skipWs(q + label.length);
+            if (s[k] === ':') {
+                const r = skipWs(k + 1);
+                if (r < n) {
+                    let end = r;
+                    while (end < n && !isLineTerminator(s[end]))
+                        end++;
+                    while (end > r + 1 && isWs(s[end - 1]))
+                        end--;
+                    return s.slice(r, end);
+                }
+                for (let i = n - 1; i > k; i--)
+                    if (!isLineTerminator(s[i]))
+                        return s[i];
+                return null;
+            }
+        }
+        p = nextLineStart(q);
+    }
+    return null;
+}
+export function taskRow(s) {
+    const n = s.length;
+    const wsStart = new Array(n + 1);
+    wsStart[0] = 0;
+    for (let i = 1; i <= n; i++)
+        wsStart[i] = isWs(s[i - 1]) ? wsStart[i - 1] : i;
+    const nextDash = new Array(n + 1).fill(-1);
+    for (let i = n - 1; i >= 0; i--) {
+        nextDash[i] = nextDash[i + 1];
+        if (s[i] !== '—' || !isWs(s[i - 1]))
+            continue;
+        let j = i + 1;
+        if (!isWs(s[j]))
+            continue;
+        while (j < n && isWs(s[j]))
+            j++;
+        if (isWord(s[j]))
+            nextDash[i] = i;
+    }
+    const terminators = new Array(n + 1);
+    terminators[0] = 0;
+    for (let i = 0; i < n; i++)
+        terminators[i + 1] = terminators[i] + (isLineTerminator(s[i]) ? 1 : 0);
+    const clean = (a, b) => terminators[b] === terminators[a];
+    const statusAt = (dash) => {
+        let j = dash + 1;
+        while (isWs(s[j]))
+            j++;
+        let end = j;
+        while (end < n && isWord(s[end]))
+            end++;
+        return s.slice(j, end);
+    };
+    for (let o = s.indexOf('**task-'); o !== -1; o = s.indexOf('**task-', o + 1)) {
+        let k = o + 7;
+        while (k < n && /[a-z0-9]/.test(s[k]))
+            k++;
+        if (k === o + 7 || s[k] !== '*' || s[k + 1] !== '*')
+            continue;
+        const a = k + 2;
+        let firstNonWs = a;
+        while (firstNonWs < n && isWs(s[firstNonWs]))
+            firstNonWs++;
+        if (firstNonWs === a)
+            continue;
+        if (firstNonWs < n && firstNonWs + 2 <= n) {
+            const dash = nextDash[firstNonWs + 2] ?? -1;
+            if (dash !== -1) {
+                const te = Math.max(firstNonWs + 1, wsStart[dash]);
+                if (clean(firstNonWs, te)) {
+                    return { id: s.slice(o + 2, k), title: s.slice(firstNonWs, te), status: statusAt(dash) };
+                }
+            }
+        }
+        if (firstNonWs < n && nextDash[firstNonWs] === firstNonWs) {
+            for (let ts = firstNonWs - 2; ts >= a + 1; ts--) {
+                if (!isLineTerminator(s[ts])) {
+                    return { id: s.slice(o + 2, k), title: s[ts], status: statusAt(firstNonWs) };
+                }
+            }
+        }
+    }
+    return null;
+}
+export function stripErrorPrefixes(s) {
+    const isError = (t, i) => t.slice(i, i + 6).toLowerCase() === 'error:';
+    let cut = 0;
+    for (;;) {
+        let i = cut;
+        while (i < s.length && isWs(s[i]))
+            i++;
+        if (!isError(s, i))
+            break;
+        i += 6;
+        while (i < s.length && isWs(s[i]))
+            i++;
+        cut = i;
+    }
+    const t = s.slice(cut);
+    let out = '';
+    let i = 0;
+    while (i < t.length) {
+        if (isError(t, i) && (i === 0 || !isWord(t[i - 1]))) {
+            let j = i;
+            let count = 0;
+            while (isError(t, j)) {
+                j += 6;
+                while (j < t.length && isWs(t[j]))
+                    j++;
+                count++;
+            }
+            if (count >= 2) {
+                i = j;
+                continue;
+            }
+        }
+        out += t[i];
+        i++;
+    }
+    return out;
+}
+function replaceMarkdownLinks(s, image) {
+    const opener = image ? '![' : '[';
+    let out = '';
+    let copied = 0;
+    let nextClose = -2;
+    let nextParen = -2;
+    for (let at = s.indexOf(opener); at !== -1;) {
+        const labelStart = at + opener.length;
+        if (nextClose < labelStart)
+            nextClose = s.indexOf(']', labelStart);
+        if (nextClose === -1)
+            break;
+        const close = nextClose;
+        if (s[close + 1] !== '(') {
+            at = s.indexOf(opener, close + 1);
+            continue;
+        }
+        if (nextParen < close + 2)
+            nextParen = s.indexOf(')', close + 2);
+        if (nextParen === -1)
+            break;
+        out += s.slice(copied, at) + (image ? ' ' : s.slice(labelStart, close));
+        copied = nextParen + 1;
+        at = s.indexOf(opener, copied);
+    }
+    return out + s.slice(copied);
+}
+export function stripMarkdownImages(s) {
+    return replaceMarkdownLinks(s, true);
+}
+export function unwrapMarkdownLinks(s) {
+    return replaceMarkdownLinks(s, false);
+}
+function httpAt(s, at) {
+    const scheme = s.slice(at, at + 8).toLowerCase();
+    return scheme.startsWith('http://') || scheme.startsWith('https://');
+}
+export function urlError(s, url) {
+    const text = fold(s);
+    const needle = fold(url);
+    const n = s.length;
+    const skipWs = (from) => {
+        let i = from;
+        while (i < n && isWs(s[i]))
+            i++;
+        return i;
+    };
+    for (let at = text.indexOf(needle); at !== -1; at = text.indexOf(needle, at + 1)) {
+        const colon = skipWs(at + needle.length);
+        if (s[colon] !== ':')
+            continue;
+        const start = skipWs(colon + 1);
+        for (let i = start; i < n;) {
+            if (!isWs(s[i])) {
+                i++;
+                continue;
+            }
+            const runEnd = skipWs(i);
+            if (httpAt(s, runEnd))
+                return s.slice(start, i);
+            i = runEnd;
+        }
+        return s.slice(start);
+    }
+    return null;
+}
+export function foldForTest(s) {
+    return fold(s);
+}

package/dist/core/turns/tool-kind.d.ts

@@ -0,0 +1,3 @@
+export type ToolKind = 'read' | 'list' | 'glob' | 'grep' | 'write' | 'edit' | 'apply_patch' | 'bash' | 'pty' | 'web_search' | 'webfetch' | 'media' | 'show' | 'task' | 'delegate' | 'sessions' | 'todowrite' | 'question' | 'memory' | 'connectors' | 'automations' | 'projects' | 'skill' | 'context' | 'retired' | 'other';
+export declare function toolKind(name: string): ToolKind;
+export declare function inputPath(input: Record<string, unknown> | undefined): string | undefined;

package/dist/core/turns/tool-kind.js

@@ -0,0 +1,99 @@
+const TOOL_KIND = {};
+function kind(value, names) {
+    for (const name of names)
+        TOOL_KIND[name] = value;
+}
+kind('read', ['read']);
+kind('list', ['list', 'ls']);
+kind('glob', ['glob']);
+kind('grep', ['grep']);
+kind('write', ['write']);
+kind('edit', ['edit', 'multiedit', 'morph_edit']);
+kind('apply_patch', ['apply_patch', 'patch']);
+kind('bash', ['bash']);
+kind('web_search', ['web_search', 'websearch', 'image_search']);
+kind('webfetch', ['webfetch', 'web_fetch', 'scrape_webpage', 'scrapewebpage']);
+kind('media', ['image_gen', 'video_gen']);
+kind('show', ['show', 'show_user', 'presentation_gen']);
+kind('task', ['task']);
+kind('delegate', [
+    'agent_spawn',
+    'agent_task',
+    'agent_task_create',
+    'agent_task_start',
+    'task_create',
+    'task_start',
+    'session_spawn',
+    'session_start_background',
+    'agent_message',
+    'agent_task_message',
+    'task_message',
+    'agent_task_update',
+    'task_update',
+    'session_message',
+    'agent_status',
+    'agent_task_list',
+    'agent_task_get',
+    'task_list',
+    'task_get',
+    'agent_stop',
+    'agent_task_cancel',
+    'task_cancel',
+    'agent_task_approve',
+    'task_approve',
+    'task_done',
+    'task_delete',
+]);
+kind('todowrite', ['todowrite', 'todo_write', 'todoread']);
+kind('question', ['question', 'ask']);
+kind('memory', ['memory', 'memory_search', 'mem_search', 'ltm_search', 'get_mem']);
+kind('connectors', [
+    'connector_get',
+    'connector_list',
+    'connector_setup',
+    'beeuni_connector_call',
+    'beeuni_connectors',
+    'beeuni_connectors_connectors',
+    'beeuni_connectors_discover',
+    'beeuni_connectors_describe',
+    'beeuni_connectors_call',
+    'beeuni_connector_describe',
+    'beeuni_connector_discover',
+]);
+kind('automations', ['triggers']);
+kind('skill', ['skill']);
+kind('context', ['prune', 'distill', 'compress', 'context_info']);
+kind('retired', [
+    'integration_list',
+    'integration_connect',
+    'integration_search',
+    'integration_actions',
+    'integration_run',
+    'integration_request',
+    'integration_exec',
+]);
+const PREFIX_KIND = [
+    ['pty_', 'pty'],
+    ['agent_', 'delegate'],
+    ['task_', 'delegate'],
+    ['session_', 'sessions'],
+    ['trigger_', 'automations'],
+    ['project_', 'projects'],
+];
+export function toolKind(name) {
+    const normalized = name.replace(/^oc[-_]/, '').replace(/-/g, '_');
+    const known = TOOL_KIND[normalized];
+    if (known)
+        return known;
+    for (const [prefix, value] of PREFIX_KIND)
+        if (normalized.startsWith(prefix))
+            return value;
+    return 'other';
+}
+export function inputPath(input) {
+    for (const value of [input?.filePath, input?.file_path, input?.path]) {
+        if (typeof value === 'string' && value)
+            return value;
+    }
+    return undefined;
+}

package/dist/core/turns/tool-registry.d.ts

@@ -0,0 +1,8 @@
+export type ToolCategory = 'shell' | 'files' | 'search' | 'edit' | 'web' | 'task' | 'other';
+export interface ToolInfoEntry {
+    label: string;
+    category: ToolCategory;
+}
+export declare function normalizeToolName(name: string): string;
+export declare function humanizeToolName(name: string): string;
+export declare function toolInfo(name: string): ToolInfoEntry;

package/dist/core/turns/tool-registry.js

@@ -0,0 +1,87 @@
+import { toolKind } from './tool-kind.js';
+const TOOL_LABEL = {
+    bash: 'Shell',
+    pty_spawn: 'Spawn Terminal',
+    pty_read: 'Terminal Output',
+    pty_write: 'Terminal Input',
+    pty_input: 'Terminal Input',
+    pty_kill: 'Kill Process',
+    read: 'Read File',
+    list: 'List Directory',
+    ls: 'List Directory',
+    write: 'Write File',
+    edit: 'Edit File',
+    multiedit: 'Edit File',
+    morph_edit: 'Edit File',
+    apply_patch: 'Apply Patch',
+    patch: 'Apply Patch',
+    grep: 'Search Code',
+    glob: 'Find Files',
+    image_search: 'Image Search',
+    session_search: 'Search Sessions',
+    webfetch: 'Fetch Page',
+    scrape_webpage: 'Scrape Page',
+    websearch: 'Web Search',
+    web_search: 'Web Search',
+    image_gen: 'Generate Image',
+    video_gen: 'Generate Video',
+    task: 'Delegate to Agent',
+    todowrite: 'Plan Tasks',
+    todoread: 'Read Plan',
+    question: 'Ask Question',
+    presentation_gen: 'Presentation',
+    show: 'Show Output',
+    show_user: 'Show Output',
+    prune: 'Prune Context',
+    distill: 'Distill Context',
+    compress: 'Compress Context',
+    context_info: 'Context Info',
+};
+const CATEGORY_OF_KIND = {
+    read: 'files',
+    list: 'files',
+    glob: 'search',
+    grep: 'search',
+    write: 'edit',
+    edit: 'edit',
+    apply_patch: 'edit',
+    bash: 'shell',
+    pty: 'shell',
+    web_search: 'web',
+    webfetch: 'web',
+    media: 'web',
+    show: 'task',
+    task: 'task',
+    delegate: 'task',
+    sessions: 'task',
+    todowrite: 'task',
+    question: 'task',
+    automations: 'task',
+    projects: 'task',
+    memory: 'other',
+    connectors: 'other',
+    skill: 'other',
+    context: 'other',
+    retired: 'other',
+    other: 'other',
+};
+function stripOcPrefix(name) {
+    return name.replace(/^oc[-_]/, '');
+}
+export function normalizeToolName(name) {
+    return stripOcPrefix(name).replace(/-/g, '_');
+}
+export function humanizeToolName(name) {
+    const normalized = normalizeToolName(name);
+    return normalized
+        .split(/[_\s]+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+export function toolInfo(name) {
+    return {
+        label: TOOL_LABEL[normalizeToolName(name)] ?? humanizeToolName(name),
+        category: CATEGORY_OF_KIND[toolKind(name)],
+    };
+}

package/dist/core/turns/tools/agent-helpers.d.ts

@@ -0,0 +1,9 @@
+export declare function cleanWorkerOutput(raw: string): string;
+export declare function isShortOutput(cleaned: string): boolean;
+export declare function extractWorkerPreview(cleaned: string): string | null;
+export declare function parseTaskRows(output: string): Array<{
+    id: string;
+    title: string;
+    status: string;
+    sessionId?: string;
+}>;

package/dist/core/turns/tools/agent-helpers.js

@@ -0,0 +1,53 @@
+import { removeTagBlocks, taskRow } from '../text-scan.js';
+export function cleanWorkerOutput(raw) {
+    if (!raw)
+        return '';
+    let text = raw;
+    text = text.replace(/^##\s*Worker Result\s*\n/i, '');
+    text = text.replace(/^\*\*Agent:\*\*.*\n?/m, '');
+    text = text.replace(/^\*\*Task:\*\*.*\n?/m, '');
+    text = text.replace(/^\*\*Status:\*\*.*\n?/m, '');
+    text = text.replace(/^\*\*Session:\*\*.*\n?/m, '');
+    text = text.replace(/^\*\*Duration:\*\*.*\n?/m, '');
+    text = removeTagBlocks(text, 'beeuni_goal_system');
+    text = text.replace(/^Task \*\*task-[a-z0-9]+\*\* created and started\..*$/gm, '');
+    text = text.replace(/^Task \*\*task-[a-z0-9]+\*\* created:.*$/gm, '');
+    text = text.replace(/^Task \*\*task-[a-z0-9]+\*\* started\..*$/gm, '');
+    text = text.replace(/^Task \*\*task-[a-z0-9]+\*\* failed to start.*$/gm, '');
+    text = text.replace(/^Message sent to task.*$/gm, '');
+    text = text.replace(/^Task \*\*task-[a-z0-9]+\*\* approved.*$/gm, '');
+    text = text.replace(/^Task \*\*task-[a-z0-9]+\*\* cancelled.*$/gm, '');
+    text = text.replace(/Worker session: ses_[a-zA-Z0-9]+/g, '');
+    text = text.replace(/^---\s*\n/gm, '');
+    text = text.trim();
+    return text || '';
+}
+export function isShortOutput(cleaned) {
+    if (!cleaned)
+        return false;
+    const lines = cleaned.split('\n').filter((l) => l.trim());
+    return lines.length <= 3;
+}
+export function extractWorkerPreview(cleaned) {
+    if (!cleaned)
+        return null;
+    const lines = cleaned.split('\n').filter((l) => l.trim() && !l.startsWith('#'));
+    const first = lines[0]?.replace(/^\*\*.*?\*\*\s*/, '').trim();
+    if (!first)
+        return null;
+    return first.length > 120 ? first.slice(0, 120).trim() + '…' : first;
+}
+export function parseTaskRows(output) {
+    if (!output)
+        return [];
+    const rows = [];
+    const lines = output.split('\n').filter((l) => l.trim());
+    for (const line of lines) {
+        const row = taskRow(line);
+        if (row) {
+            const sessionMatch = line.match(/\bses_[a-zA-Z0-9]+/);
+            rows.push({ ...row, sessionId: sessionMatch?.[0] });
+        }
+    }
+    return rows;
+}

package/dist/core/turns/tools/file-verb.d.ts

@@ -0,0 +1,10 @@
+export interface FileVerb {
+    verb: string;
+    running: string;
+    failed: string;
+}
+export type FileAction = 'write' | 'edit' | 'delete' | 'rename' | 'change' | 'read' | 'list';
+export declare const FILE_VERBS: Record<FileAction, FileVerb>;
+export type FilePhase = 'running' | 'done' | 'failed';
+export declare function fileVerb(action: FileAction, phase: FilePhase): string;
+export declare function filePhase(running: boolean, isError: boolean): FilePhase;

package/dist/core/turns/tools/file-verb.js

@@ -0,0 +1,22 @@
+export const FILE_VERBS = {
+    write: { verb: 'Wrote', running: 'Writing', failed: "Couldn't write" },
+    edit: { verb: 'Edited', running: 'Editing', failed: "Couldn't update" },
+    delete: { verb: 'Deleted', running: 'Deleting', failed: "Couldn't delete" },
+    rename: { verb: 'Renamed', running: 'Renaming', failed: "Couldn't rename" },
+    change: { verb: 'Changed', running: 'Changing', failed: "Couldn't apply" },
+    read: { verb: 'Read', running: 'Reading', failed: "Couldn't read" },
+    list: { verb: 'Listed', running: 'Listing', failed: "Couldn't list" },
+};
+export function fileVerb(action, phase) {
+    const verbs = FILE_VERBS[action];
+    if (phase === 'running')
+        return verbs.running;
+    if (phase === 'failed')
+        return verbs.failed;
+    return verbs.verb;
+}
+export function filePhase(running, isError) {
+    if (isError)
+        return 'failed';
+    return running ? 'running' : 'done';
+}

package/dist/core/turns/tools/index.d.ts

@@ -0,0 +1,14 @@
+export * from './agent-helpers.js';
+export * from './file-verb.js';
+export * from './memory-helpers.js';
+export * from './patch-summary.js';
+export * from './presentation-helpers.js';
+export * from './question-helpers.js';
+export * from './read-helpers.js';
+export * from './search-query.js';
+export * from './show-availability.js';
+export * from './skill-helpers.js';
+export * from './tool-meta.js';
+export * from './tool-outcome.js';
+export * from './tool-output-format.js';
+export * from './web-helpers.js';

package/dist/core/turns/tools/index.js

@@ -0,0 +1,14 @@
+export * from './agent-helpers.js';
+export * from './file-verb.js';
+export * from './memory-helpers.js';
+export * from './patch-summary.js';
+export * from './presentation-helpers.js';
+export * from './question-helpers.js';
+export * from './read-helpers.js';
+export * from './search-query.js';
+export * from './show-availability.js';
+export * from './skill-helpers.js';
+export * from './tool-meta.js';
+export * from './tool-outcome.js';
+export * from './tool-output-format.js';
+export * from './web-helpers.js';

package/dist/core/turns/tools/memory-helpers.d.ts

@@ -0,0 +1,15 @@
+export declare const MEMORY_VERBS: Record<string, string>;
+export declare function memoryRelPath(p?: string): string;
+interface MemoryDirEntry {
+    path: string;
+    size: string;
+    isDir: boolean;
+}
+export declare function parseMemoryView(output: string, viewedPath: string): {
+    type: 'dir';
+    entries: MemoryDirEntry[];
+} | {
+    type: 'file';
+    content: string;
+} | null;
+export {};