langflower 0.0.10 → 0.1.1

package/vendor/server/dist/crawl/create-web-fetch.js

@@ -1,128 +0,0 @@
-import { assertUrlSafeForFetch } from './ssrf-guard.js';
-const DEFAULT_TIMEOUT_MS = 30_000;
-const DEFAULT_MAX_BYTES = 5_000_000;
-const MAX_REDIRECTS = 5;
-const headersToRecord = (headers) => {
-    const out = {};
-    headers.forEach((value, key) => {
-        out[key] = value;
-    });
-    return out;
-};
-const readBodyLimited = async (response, maxBytes) => {
-    if (response.body === null) {
-        return '';
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let total = 0;
-    let text = '';
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        if (value === undefined) {
-            continue;
-        }
-        total += value.byteLength;
-        if (total > maxBytes) {
-            await reader.cancel();
-            throw new Error(`Response exceeded maxBytes (${maxBytes}).`);
-        }
-        text += decoder.decode(value, { stream: true });
-    }
-    text += decoder.decode();
-    return text;
-};
-/**
- * SSRF-guarded HTTP GET for crawl / Fetch URL nodes.
- * Validates every redirect hop; truncates body at `maxBytes`.
- */
-export const createWebFetch = (options = {}) => {
-    const fetchImpl = options.fetchImpl ?? fetch;
-    return async (request) => {
-        const timeoutMs = typeof request.timeoutMs === 'number' && request.timeoutMs > 0
-            ? request.timeoutMs
-            : DEFAULT_TIMEOUT_MS;
-        const maxBytes = typeof request.maxBytes === 'number' && request.maxBytes > 0
-            ? request.maxBytes
-            : DEFAULT_MAX_BYTES;
-        try {
-            let currentUrl = request.url;
-            for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
-                const safeUrl = await assertUrlSafeForFetch(currentUrl, {
-                    ...(options.allowedHosts !== undefined
-                        ? { allowedHosts: options.allowedHosts }
-                        : {}),
-                });
-                const controller = new AbortController();
-                const timer = setTimeout(() => controller.abort(), timeoutMs);
-                try {
-                    const response = await fetchImpl(safeUrl.toString(), {
-                        method: 'GET',
-                        redirect: 'manual',
-                        signal: controller.signal,
-                        headers: {
-                            Accept: 'text/html,application/xhtml+xml,*/*;q=0.8',
-                            'User-Agent': 'LangflowerCrawl/0.1',
-                        },
-                    });
-                    if (response.status >= 300 &&
-                        response.status < 400 &&
-                        response.headers.has('location')) {
-                        const location = response.headers.get('location');
-                        if (location === null || location.length === 0) {
-                            return {
-                                ok: false,
-                                status: response.status,
-                                url: safeUrl.toString(),
-                                headers: headersToRecord(response.headers),
-                                body: '',
-                                error: 'Redirect missing Location header.',
-                            };
-                        }
-                        currentUrl = new URL(location, safeUrl).toString();
-                        continue;
-                    }
-                    const body = await readBodyLimited(response, maxBytes);
-                    return {
-                        ok: response.ok,
-                        status: response.status,
-                        url: safeUrl.toString(),
-                        headers: headersToRecord(response.headers),
-                        body,
-                        ...(response.ok
-                            ? {}
-                            : {
-                                error: `HTTP ${response.status} ${response.statusText}`,
-                            }),
-                    };
-                }
-                finally {
-                    clearTimeout(timer);
-                }
-            }
-            return {
-                ok: false,
-                status: 0,
-                url: currentUrl,
-                headers: {},
-                body: '',
-                error: `Too many redirects (>${MAX_REDIRECTS}).`,
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                ok: false,
-                status: 0,
-                url: request.url,
-                headers: {},
-                body: '',
-                error: message,
-            };
-        }
-    };
-};
-//# sourceMappingURL=create-web-fetch.js.map

package/vendor/server/dist/crawl/create-web-fetch.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=create-web-fetch.test.d.ts.map

package/vendor/server/dist/crawl/create-web-fetch.test.js

@@ -1,43 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createWebFetch } from './create-web-fetch.js';
-describe('createWebFetch', () => {
-    it('returns body from a mocked public fetch (offline)', async () => {
-        const fetchImpl = vi.fn(async () => new Response('<html><body>Hi</body></html>', {
-            status: 200,
-            headers: { 'content-type': 'text/html' },
-        }));
-        // Public IP literal avoids DNS; fetch is mocked.
-        const webFetch = createWebFetch({ fetchImpl });
-        const result = await webFetch({ url: 'https://8.8.8.8/' });
-        expect(result.ok).toBe(true);
-        expect(result.status).toBe(200);
-        expect(result.body).toContain('Hi');
-        expect(fetchImpl).toHaveBeenCalled();
-    });
-    it('does not call fetch for blocked URLs', async () => {
-        const fetchImpl = vi.fn();
-        const webFetch = createWebFetch({ fetchImpl });
-        const result = await webFetch({ url: 'http://127.0.0.1/admin' });
-        expect(result.ok).toBe(false);
-        expect(result.error).toMatch(/Blocked/i);
-        expect(fetchImpl).not.toHaveBeenCalled();
-    });
-    it('re-validates redirect targets', async () => {
-        const fetchImpl = vi.fn(async (input) => {
-            const url = String(input);
-            if (url.includes('8.8.8.8')) {
-                return new Response(null, {
-                    status: 302,
-                    headers: { location: 'http://127.0.0.1/secret' },
-                });
-            }
-            return new Response('should-not-reach', { status: 200 });
-        });
-        const webFetch = createWebFetch({ fetchImpl });
-        const result = await webFetch({ url: 'https://8.8.8.8/' });
-        expect(result.ok).toBe(false);
-        expect(result.error).toMatch(/Blocked/i);
-        expect(fetchImpl).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=create-web-fetch.test.js.map

package/vendor/server/dist/crawl/ssrf-guard.d.ts

@@ -1,13 +0,0 @@
-/** True when the address is loopback, private, link-local, or metadata. */
-export declare const isBlockedIpAddress: (address: string) => boolean;
-export type AssertUrlSafeOptions = {
-    readonly allowedHosts?: readonly string[];
-    /** When true, skip DNS resolution (hostname-only checks). */
-    readonly skipDns?: boolean;
-};
-/**
- * Reject non-http(s) URLs, blocked hostnames, and (by default) private IPs
- * after DNS resolution. Optional `allowedHosts` is an exact hostname allowlist.
- */
-export declare const assertUrlSafeForFetch: (rawUrl: string, options?: AssertUrlSafeOptions) => Promise<URL>;
-//# sourceMappingURL=ssrf-guard.d.ts.map

package/vendor/server/dist/crawl/ssrf-guard.js

@@ -1,117 +0,0 @@
-import dns from 'node:dns/promises';
-import net from 'node:net';
-const BLOCKED_HOSTNAMES = new Set([
-    'localhost',
-    'localhost.localdomain',
-    'metadata.google.internal',
-]);
-const isIpv4Private = (ip) => {
-    const parts = ip.split('.').map((part) => Number(part));
-    if (parts.length !== 4 ||
-        parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-        return false;
-    }
-    const a = parts[0] ?? 0;
-    const b = parts[1] ?? 0;
-    if (a === 10) {
-        return true;
-    }
-    if (a === 127) {
-        return true;
-    }
-    if (a === 0) {
-        return true;
-    }
-    if (a === 169 && b === 254) {
-        return true;
-    }
-    if (a === 172 && b >= 16 && b <= 31) {
-        return true;
-    }
-    if (a === 192 && b === 168) {
-        return true;
-    }
-    if (a === 100 && b >= 64 && b <= 127) {
-        return true;
-    }
-    return false;
-};
-const isIpv6Private = (ip) => {
-    const normalized = ip.toLowerCase();
-    if (normalized === '::1' || normalized === '::') {
-        return true;
-    }
-    if (normalized.startsWith('fc') || normalized.startsWith('fd')) {
-        return true;
-    }
-    if (normalized.startsWith('fe80:')) {
-        return true;
-    }
-    // IPv4-mapped IPv6 (:ffff:x.x.x.x)
-    const mapped = normalized.match(/^:ffff:(\d+\.\d+\.\d+\.\d+)$/i);
-    if (mapped?.[1] !== undefined) {
-        return isIpv4Private(mapped[1]);
-    }
-    return false;
-};
-/** True when the address is loopback, private, link-local, or metadata. */
-export const isBlockedIpAddress = (address) => {
-    const family = net.isIP(address);
-    if (family === 4) {
-        return isIpv4Private(address);
-    }
-    if (family === 6) {
-        return isIpv6Private(address);
-    }
-    return true;
-};
-/**
- * Reject non-http(s) URLs, blocked hostnames, and (by default) private IPs
- * after DNS resolution. Optional `allowedHosts` is an exact hostname allowlist.
- */
-export const assertUrlSafeForFetch = async (rawUrl, options = {}) => {
-    let parsed;
-    try {
-        parsed = new URL(rawUrl);
-    }
-    catch {
-        throw new Error(`Invalid URL: ${rawUrl}`);
-    }
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        throw new Error(`Blocked URL protocol «${parsed.protocol}» (only http/https).`);
-    }
-    const hostname = parsed.hostname.toLowerCase();
-    if (hostname.length === 0) {
-        throw new Error('URL hostname is empty.');
-    }
-    if (BLOCKED_HOSTNAMES.has(hostname) ||
-        hostname.endsWith('.localhost') ||
-        hostname.endsWith('.local')) {
-        throw new Error(`Blocked hostname «${hostname}».`);
-    }
-    const allowed = options.allowedHosts?.map((host) => host.toLowerCase());
-    if (allowed !== undefined && allowed.length > 0) {
-        if (!allowed.includes(hostname)) {
-            throw new Error(`Hostname «${hostname}» is not in harness.allowedHosts.`);
-        }
-    }
-    if (net.isIP(hostname) !== 0) {
-        if (isBlockedIpAddress(hostname)) {
-            throw new Error(`Blocked IP address «${hostname}».`);
-        }
-        return parsed;
-    }
-    if (options.skipDns === true) {
-        return parsed;
-    }
-    const records = await dns.lookup(hostname, { all: true, verbatim: true });
-    if (records.length === 0) {
-        throw new Error(`DNS lookup failed for «${hostname}».`);
-    }
-    const blocked = records.find((record) => isBlockedIpAddress(record.address));
-    if (blocked !== undefined) {
-        throw new Error(`Blocked: «${hostname}» resolves to private/link-local address ${blocked.address}.`);
-    }
-    return parsed;
-};
-//# sourceMappingURL=ssrf-guard.js.map

package/vendor/server/dist/crawl/ssrf-guard.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ssrf-guard.test.d.ts.map

package/vendor/server/dist/crawl/ssrf-guard.test.js

@@ -1,46 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { assertUrlSafeForFetch, isBlockedIpAddress } from './ssrf-guard.js';
-describe('isBlockedIpAddress', () => {
-    it.each([
-        '127.0.0.1',
-        '10.0.0.1',
-        '192.168.1.1',
-        '172.16.0.1',
-        '169.254.169.254',
-        '0.0.0.0',
-        '::1',
-        'fe80::1',
-        'fc00::1',
-    ])('blocks %s', (ip) => {
-        expect(isBlockedIpAddress(ip)).toBe(true);
-    });
-    it.each(['8.8.8.8', '1.1.1.1', '2001:4860:4860::8888'])('allows public %s', (ip) => {
-        expect(isBlockedIpAddress(ip)).toBe(false);
-    });
-});
-describe('assertUrlSafeForFetch', () => {
-    it('rejects non-http protocols', async () => {
-        await expect(assertUrlSafeForFetch('file:///etc/passwd', { skipDns: true })).rejects.toThrow(/protocol/i);
-    });
-    it('rejects localhost hostnames without DNS', async () => {
-        await expect(assertUrlSafeForFetch('http://localhost/secret', { skipDns: true })).rejects.toThrow(/hostname/i);
-        await expect(assertUrlSafeForFetch('http://127.0.0.1/', { skipDns: true })).rejects.toThrow(/IP/i);
-    });
-    it('enforces allowedHosts allowlist', async () => {
-        await expect(assertUrlSafeForFetch('https://evil.example/x', {
-            skipDns: true,
-            allowedHosts: ['docs.example'],
-        })).rejects.toThrow(/allowedHosts/i);
-        await expect(assertUrlSafeForFetch('https://docs.example/x', {
-            skipDns: true,
-            allowedHosts: ['docs.example'],
-        })).resolves.toMatchObject({ hostname: 'docs.example' });
-    });
-    it('allows public hostnames when DNS skipped', async () => {
-        const url = await assertUrlSafeForFetch('https://example.com/path', {
-            skipDns: true,
-        });
-        expect(url.toString()).toBe('https://example.com/path');
-    });
-});
-//# sourceMappingURL=ssrf-guard.test.js.map

package/vendor/server/dist/create-server.d.ts

@@ -1,10 +0,0 @@
-import { type TerminalExecutionProgressStatus } from '@langflower/shared/langflower.js';
-import http from 'node:http';
-export type CreateServerOptions = {
-    readonly projectDir: string;
-    readonly port?: number;
-    readonly uiDistPath?: string;
-    /** Fired once when a run settles naturally (`runner.done`). */
-    readonly onRunSettled?: (status: TerminalExecutionProgressStatus) => void;
-};
-export declare function createServer(options: CreateServerOptions): Promise<http.Server>;

package/vendor/server/dist/create-server.js

@@ -1,60 +0,0 @@
-import { hasCustomNodePacks } from '@langflower/compiler/compile-project-nodes';
-import { langflowerWsConfig, resolveServerLogsEnabled, } from '@langflower/shared/langflower.js';
-import { createServer as createWsBridge } from '@langflower/websocket-bridge/create-server';
-import express from 'express';
-import http from 'node:http';
-import path from 'node:path';
-import { attachLangflowerBridge } from './bridge/attach-langflower-bridge.js';
-import { listenHttpServer } from './listen-http-server.js';
-import { createServerContext } from './server-context.js';
-/** Warm custom-node registry before accepting clients / opening the browser. */
-const warmCustomPalette = async (context) => {
-    if (!(await hasCustomNodePacks(context.projectDir))) {
-        context.customPaletteService.applyEmptyOk();
-        return;
-    }
-    process.stdout.write('Compiling custom nodes ...');
-    const snapshot = await context.customPaletteService.update(context.projectDir);
-    console.log(' done');
-    if (snapshot.status === 'error' || snapshot.status === 'partial') {
-        const count = String(snapshot.errors.length);
-        console.warn(`Custom nodes compile ${snapshot.status}: ${count} pack error(s)`);
-    }
-};
-export async function createServer(options) {
-    const context = await createServerContext(options.projectDir);
-    await warmCustomPalette(context);
-    const app = express();
-    if (options.uiDistPath !== undefined) {
-        const uiRoot = path.resolve(options.uiDistPath);
-        app.use(express.static(uiRoot));
-        app.get('*', (_request, response) => {
-            response.sendFile(path.join(uiRoot, 'index.html'));
-        });
-    }
-    const toolConfig = await context.configService.read();
-    const langflowerConfig = await context.langflowerConfigService.read();
-    const port = options.port ?? toolConfig.port;
-    const httpServer = http.createServer(app);
-    const bridge = createWsBridge(langflowerWsConfig, { httpServer });
-    const detachBridge = attachLangflowerBridge(bridge, context, {
-        serverLogsEnabled: resolveServerLogsEnabled(langflowerConfig),
-        ...(options.onRunSettled !== undefined
-            ? { onRunSettled: options.onRunSettled }
-            : {}),
-    });
-    httpServer.on('close', () => {
-        void detachBridge();
-        bridge.close();
-    });
-    try {
-        await listenHttpServer(httpServer, port, '127.0.0.1');
-    }
-    catch (error) {
-        await detachBridge();
-        bridge.close();
-        httpServer.close();
-        throw error;
-    }
-    return httpServer;
-}

package/vendor/server/dist/harness/pending-permission-asks.d.ts

@@ -1,14 +0,0 @@
-import type { RunnerPermissionAskPayload, RunnerPermissionReplyPayload } from '@langflower/shared/langflower.js';
-import type { PermissionAskRequest } from '@langflower/tools/permission';
-/**
- * Run-scoped registry for feed `permission.ask` pause/resume.
- * `harness.invoke` awaits {@link requestPermission}; UI replies resolve it.
- */
-export declare class PendingPermissionAsks {
-    private readonly pending;
-    list(): readonly RunnerPermissionAskPayload[];
-    requestPermission: (runId: string, nodeId: string, request: PermissionAskRequest, emitAsk: (payload: RunnerPermissionAskPayload) => void) => Promise<"allow" | "deny">;
-    reply: (payload: RunnerPermissionReplyPayload) => boolean;
-    /** Fail closed all outstanding asks (interrupt / run end). */
-    denyAll: (runId?: string) => void;
-}

package/vendor/server/dist/harness/pending-permission-asks.js

@@ -1,45 +0,0 @@
-/**
- * Run-scoped registry for feed `permission.ask` pause/resume.
- * `harness.invoke` awaits {@link requestPermission}; UI replies resolve it.
- */
-export class PendingPermissionAsks {
-    pending = new Map();
-    list() {
-        return [...this.pending.values()].map((entry) => entry.payload);
-    }
-    requestPermission = (runId, nodeId, request, emitAsk) => {
-        const askId = crypto.randomUUID();
-        const payload = {
-            runId,
-            askId,
-            nodeId,
-            toolId: request.toolId,
-            detail: request.detail,
-            summary: request.summary,
-        };
-        return new Promise((resolve) => {
-            this.pending.set(askId, { payload, resolve });
-            emitAsk(payload);
-        });
-    };
-    reply = (payload) => {
-        const entry = this.pending.get(payload.askId);
-        if (entry === undefined) {
-            return false;
-        }
-        if (entry.payload.runId !== payload.runId) {
-            return false;
-        }
-        this.pending.delete(payload.askId);
-        entry.resolve(payload.decision === 'allow' ? 'allow' : 'deny');
-        return true;
-    };
-    /** Fail closed all outstanding asks (interrupt / run end). */
-    denyAll = (runId) => {
-        const entries = [...this.pending.entries()].filter(([, entry]) => runId === undefined || entry.payload.runId === runId);
-        for (const [askId, entry] of entries) {
-            this.pending.delete(askId);
-            entry.resolve('deny');
-        }
-    };
-}

package/vendor/server/dist/harness/permission.d.ts

@@ -1,23 +0,0 @@
-/**
- * Thin server adapter for OpenCode-style harness permissions.
- *
- * Resolution logic lives in `@langflower/tools/permission`. This module wires
- * project config into `createProjectHarness` and documents the injection point
- * referenced by docs/CONFIG.md.
- */
-import type { LangflowerHarnessConfig, LangflowerPermissionConfig } from '@langflower/shared/langflower.js';
-import { type Harness, type PermissionAskRequest } from '@langflower/tools/create-project-harness';
-import { resolvePermission, type PermissionDecision } from '@langflower/tools/permission';
-export { resolvePermission };
-export type CreatePermissionHarnessOptions = {
-    readonly projectRoot: string;
-    readonly permission?: LangflowerPermissionConfig;
-    readonly harness?: LangflowerHarnessConfig;
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<PermissionDecision>;
-};
-/**
- * Build a project harness with runtime permission gating.
- * Bash is enabled at the handler level; allow/ask/deny comes from policy.
- */
-export declare const createPermissionAwareHarness: (options: CreatePermissionHarnessOptions) => Harness;
-//# sourceMappingURL=permission.d.ts.map

package/vendor/server/dist/harness/permission.js

@@ -1,31 +0,0 @@
-/**
- * Thin server adapter for OpenCode-style harness permissions.
- *
- * Resolution logic lives in `@langflower/tools/permission`. This module wires
- * project config into `createProjectHarness` and documents the injection point
- * referenced by docs/CONFIG.md.
- */
-import { createProjectHarness, } from '@langflower/tools/create-project-harness';
-import { resolvePermission, } from '@langflower/tools/permission';
-export { resolvePermission };
-/**
- * Build a project harness with runtime permission gating.
- * Bash is enabled at the handler level; allow/ask/deny comes from policy.
- */
-export const createPermissionAwareHarness = (options) => createProjectHarness({
-    projectRoot: options.projectRoot,
-    bashEnabled: true,
-    ...(options.harness?.denyPaths !== undefined
-        ? { denyPaths: options.harness.denyPaths }
-        : {}),
-    ...(options.harness?.allowedRoots !== undefined
-        ? { allowedRoots: options.harness.allowedRoots }
-        : {}),
-    ...(options.permission !== undefined
-        ? { permission: options.permission }
-        : {}),
-    ...(options.requestPermission !== undefined
-        ? { requestPermission: options.requestPermission }
-        : {}),
-});
-//# sourceMappingURL=permission.js.map

package/vendor/server/dist/harness/permission.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=permission.test.d.ts.map

package/vendor/server/dist/harness/permission.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createPermissionAwareHarness, resolvePermission, } from './permission.js';
-import { PendingPermissionAsks } from './pending-permission-asks.js';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach } from 'vitest';
-describe('server harness permission adapter', () => {
-    let projectRoot;
-    beforeEach(async () => {
-        projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-perm-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectRoot, { recursive: true, force: true });
-    });
-    it('re-exports resolvePermission for CONFIG.md injection point', () => {
-        expect(resolvePermission(undefined, 'bash', 'rm -rf /')).toBe('deny');
-    });
-    it('write ask → allow completes; deny fails closed', async () => {
-        const pending = new PendingPermissionAsks();
-        const emitted = [];
-        let autoReply = 'deny';
-        const harness = createPermissionAwareHarness({
-            projectRoot,
-            permission: { write: { '*': 'ask' }, bash: { '*': 'ask' } },
-            requestPermission: (request) => pending.requestPermission('run-1', 'llm-1', request, (payload) => {
-                emitted.push(payload.summary);
-                pending.reply({
-                    runId: payload.runId,
-                    askId: payload.askId,
-                    decision: autoReply,
-                });
-            }),
-        });
-        const denied = await harness.invoke({
-            toolId: 'write',
-            args: { path: 'a.txt', content: 'x' },
-        });
-        expect(denied.ok).toBe(false);
-        expect(emitted).toHaveLength(1);
-        autoReply = 'allow';
-        const allowed = await harness.invoke({
-            toolId: 'write',
-            args: { path: 'a.txt', content: 'ok' },
-        });
-        expect(allowed.ok).toBe(true);
-        expect(await fs.readFile(path.join(projectRoot, 'a.txt'), 'utf8')).toBe('ok');
-    });
-});
-//# sourceMappingURL=permission.test.js.map

package/vendor/server/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { createServer, type CreateServerOptions } from './create-server.js';
-export { bootstrapProject } from './bootstrap/project-bootstrap.service.js';
-export { createServerContext, type ServerContext } from './server-context.js';
-//# sourceMappingURL=index.d.ts.map

package/vendor/server/dist/index.js

@@ -1,4 +0,0 @@
-export { createServer } from './create-server.js';
-export { bootstrapProject } from './bootstrap/project-bootstrap.service.js';
-export { createServerContext } from './server-context.js';
-//# sourceMappingURL=index.js.map

package/vendor/server/dist/kb/chunk-text.d.ts

@@ -1,8 +0,0 @@
-/**
- * Split text into overlapping character windows (paragraph-aware when possible).
- */
-export declare const chunkText: (text: string, options?: {
-    readonly maxChars?: number;
-    readonly overlap?: number;
-}) => readonly string[];
-//# sourceMappingURL=chunk-text.d.ts.map