@deepexi/datasense-connector 3.0.1 → 3.1.0

package/testing/replay.js

@@ -1,313 +0,0 @@
-import { createHash } from 'node:crypto';
-import { checkCompliance, scopedTables } from './compliance.js';
-import { canonicalJson, canonicalRequestUrl, parseFixtures, } from './fixtures.js';
-import { redactSecretValues, redactUrl } from './redaction.js';
-export class FixtureReplayError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.name = 'FixtureReplayError';
-        this.code = code;
-    }
-}
-const MISMATCH = 'FIXTURE_EXCHANGE_MISMATCH';
-const PLAIN_HANDLE = /ontos:secret:([A-Za-z_][A-Za-z0-9_]*)/g;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function preview(text, max = 200) {
-    return text.length > max ? `${text.slice(0, max)}…` : text;
-}
-export function createReplayHost(fixture) {
-    const caseSecrets = fixture.case.secrets ?? {};
-    const secretValues = Object.values(caseSecrets);
-    const redact = (text) => redactSecretValues(text, secretValues);
-    const used = new Set();
-    const mismatched = [];
-    const failingCursors = new Map();
-    const cache = new Map();
-    const mismatch = (method, detail) => {
-        mismatched.push({ method, detail });
-        throw new FixtureReplayError(MISMATCH, `no recorded exchange in fixture "${fixture.name}" matches ${method} ${detail}`);
-    };
-    const take = (kind, matches) => {
-        for (const exchange of fixture.exchanges) {
-            if (exchange.kind !== kind || used.has(exchange.seq))
-                continue;
-            const typed = exchange;
-            if (!matches(typed))
-                continue;
-            used.add(exchange.seq);
-            return typed;
-        }
-        return null;
-    };
-    const lookupSecret = (field) => {
-        const value = Object.hasOwn(caseSecrets, field) ? caseSecrets[field] : undefined;
-        if (typeof value !== 'string')
-            throw new FixtureReplayError('EGRESS_SECRET_UNAVAILABLE', `Secret '${field}' is not in the fixture's case.json secrets`);
-        return value;
-    };
-    const http = (payload) => {
-        if (!isRecord(payload) || typeof payload.method !== 'string' || typeof payload.url !== 'string') {
-            throw new FixtureReplayError('BAD_REQUEST', 'http request must have a method and a url');
-        }
-        const query = isRecord(payload.query) ? payload.query : undefined;
-        const scriptUrl = canonicalRequestUrl(payload.url, query);
-        const url = redactUrl(scriptUrl, secretValues);
-        const bodyEncoding = payload.bodyEncoding === 'base64' ? 'base64' : 'utf8';
-        const body = typeof payload.body === 'string' ? (bodyEncoding === 'utf8' ? redact(payload.body) : payload.body) : null;
-        const method = payload.method;
-        const exchange = take('http', (item) => item.request.method === method && item.request.url === url && item.request.body === body && (body === null || item.request.bodyEncoding === bodyEncoding));
-        if (!exchange)
-            return mismatch('http', `${method} ${url}${body !== null ? ` with body ${preview(body)}` : ''}`);
-        if (exchange.error)
-            throw new FixtureReplayError(exchange.error.code, exchange.error.message);
-        if (!exchange.response)
-            throw new FixtureReplayError('HOST_CALL_FAILED', 'the recorded exchange has no response');
-        return { status: exchange.response.status, url: scriptUrl, headers: { ...exchange.response.headers }, body: exchange.response.body, bodyEncoding: exchange.response.bodyEncoding };
-    };
-    const dbQuery = (payload) => {
-        if (!isRecord(payload) || typeof payload.sql !== 'string')
-            throw new FixtureReplayError('BAD_REQUEST', 'db.query needs sql');
-        const sql = redact(payload.sql);
-        const params = canonicalJson(JSON.parse(redact(JSON.stringify(Array.isArray(payload.params) ? payload.params : []))));
-        const exchange = take('db', (item) => item.sql === sql && canonicalJson(item.params) === params);
-        if (!exchange)
-            return mismatch('db.query', `${preview(sql.replace(/\s+/g, ' ').trim())} with params ${preview(params)}`);
-        const rows = exchange.rows.map((row) => ({ ...row }));
-        const fields = exchange.fields.map((field) => ({ ...field }));
-        if (!exchange.error)
-            return { cursorId: null, fields, rows, done: true };
-        if (fields.length === 0 && rows.length === 0)
-            throw new FixtureReplayError(exchange.error.code, exchange.error.message);
-        const cursorId = `replay-${exchange.seq}`;
-        failingCursors.set(cursorId, exchange.error);
-        return { cursorId, fields, rows, done: false };
-    };
-    const crypto = (payload) => {
-        if (!isRecord(payload) || typeof payload.op !== 'string')
-            throw new FixtureReplayError('BAD_REQUEST', 'crypto request must have an op');
-        const request = JSON.parse(redact(JSON.stringify(payload)));
-        const key = canonicalJson(request);
-        const exchange = take('crypto', (item) => canonicalJson(item.request) === key);
-        if (exchange)
-            return { value: exchange.value };
-        if (request.op === 'hash') {
-            const data = request.data.replace(PLAIN_HANDLE, (_match, field) => lookupSecret(field));
-            return { value: createHash(request.algorithm).update(data, 'utf8').digest(request.encoding) };
-        }
-        return mismatch('crypto', `${request.op} ${request.algorithm}`);
-    };
-    const call = async (method, payload) => {
-        switch (method) {
-            case 'http':
-                return http(payload);
-            case 'db.query':
-                return dbQuery(payload);
-            case 'db.next': {
-                const cursorId = isRecord(payload) && typeof payload.cursorId === 'string' ? payload.cursorId : '';
-                const error = failingCursors.get(cursorId);
-                if (!error)
-                    throw new FixtureReplayError('DB_CURSOR_NOT_FOUND', "The cursor doesn't exist or was closed");
-                failingCursors.delete(cursorId);
-                throw new FixtureReplayError(error.code, error.message);
-            }
-            case 'db.close': {
-                const cursorId = isRecord(payload) && typeof payload.cursorId === 'string' ? payload.cursorId : '';
-                failingCursors.delete(cursorId);
-                return null;
-            }
-            case 'crypto':
-                return crypto(payload);
-            case 'cache.get': {
-                const key = isRecord(payload) && typeof payload.key === 'string' ? payload.key : '';
-                const entry = cache.get(key);
-                if (!entry || Date.parse(entry.expiresAt) <= Date.now())
-                    return null;
-                return entry;
-            }
-            case 'cache.set': {
-                if (!isRecord(payload) || typeof payload.key !== 'string' || typeof payload.value !== 'string' || typeof payload.ttlSeconds !== 'number') {
-                    throw new FixtureReplayError('BAD_REQUEST', 'cache.set needs key, value and ttlSeconds');
-                }
-                cache.set(payload.key, { value: payload.value, expiresAt: new Date(Date.now() + payload.ttlSeconds * 1000).toISOString() });
-                return null;
-            }
-            case 'secret.reveal': {
-                const field = isRecord(payload) && typeof payload.field === 'string' ? payload.field : '';
-                return { value: lookupSecret(field) };
-            }
-            default:
-                throw new FixtureReplayError('HOST_METHOD_UNSUPPORTED', `fixture replay does not answer ${method}`);
-        }
-    };
-    return {
-        call,
-        redact,
-        async close() {
-            failingCursors.clear();
-        },
-        unused() {
-            return fixture.exchanges.filter((exchange) => !used.has(exchange.seq)).map((exchange) => JSON.parse(JSON.stringify(exchange)));
-        },
-        mismatches() {
-            return mismatched.map((item) => ({ ...item }));
-        },
-    };
-}
-function countBy(items) {
-    const counts = {};
-    for (const item of items)
-        counts[item.table] = (counts[item.table] ?? 0) + 1;
-    return counts;
-}
-function toDeclaration(declaration) {
-    if (!declaration || !isRecord(declaration.discover))
-        return null;
-    const discover = declaration.discover;
-    return { definition: declaration.summary, streams: discover.streams, pushes: discover.pushes };
-}
-function exchangeSummary(exchange) {
-    switch (exchange.kind) {
-        case 'http':
-            return `${exchange.request.method} ${exchange.request.url}`;
-        case 'db':
-            return preview(exchange.sql.replace(/\s+/g, ' ').trim());
-        case 'crypto':
-            return `${exchange.request.op} ${exchange.request.algorithm}`;
-    }
-}
-function scopeOf(fixtureCase) {
-    if (fixtureCase.kind === 'pull')
-        return { stream: fixtureCase.stream };
-    if (fixtureCase.kind === 'push')
-        return { push: fixtureCase.push };
-    return {};
-}
-function sameCounts(expected, actual) {
-    return Object.entries(expected)
-        .filter(([table, count]) => (actual[table] ?? 0) !== count)
-        .map(([table, count]) => `${table}: expected ${count}, got ${actual[table] ?? 0}`);
-}
-function checkExpectation(fixture, result, declaration) {
-    const expect = fixture.case.expect;
-    if (!expect)
-        return [];
-    const findings = [];
-    const failed = (what, problems, detail) => {
-        findings.push({ code: 'EXPECTATION_FAILED', message: `expect.${what} does not match (${problems.join('; ')})`, detail });
-    };
-    if (expect.records) {
-        const actual = countBy(result.records);
-        const problems = sameCounts(expect.records, actual);
-        if (problems.length > 0)
-            failed('records', problems, { expected: expect.records, actual });
-    }
-    if (expect.removals) {
-        const actual = countBy(result.removals);
-        const problems = sameCounts(expect.removals, actual);
-        if (problems.length > 0)
-            failed('removals', problems, { expected: expect.removals, actual });
-    }
-    if (expect.rejected !== undefined && expect.rejected !== result.rejected.length) {
-        failed('rejected', [`expected ${expect.rejected}, got ${result.rejected.length}`], { expected: expect.rejected, actual: result.rejected.length });
-    }
-    if (expect.checkpoints !== undefined && expect.checkpoints !== result.checkpoints.length) {
-        failed('checkpoints', [`expected ${expect.checkpoints}, got ${result.checkpoints.length}`], { expected: expect.checkpoints, actual: result.checkpoints.length });
-    }
-    if (expect.tables) {
-        const actual = Object.keys(scopedTables(declaration, scopeOf(fixture.case)) ?? {}).sort();
-        const expected = [...new Set(expect.tables)].sort();
-        if (actual.length !== expected.length || actual.some((table, index) => table !== expected[index])) {
-            failed('tables', [`expected [${expected.join(', ')}], got [${actual.join(', ')}]`], { expected, actual });
-        }
-    }
-    return findings;
-}
-export async function runFixture(executor, fixture, options = {}) {
-    const fixtureCase = fixture.case;
-    const config = fixtureCase.config;
-    const secretFields = Object.keys(fixtureCase.secrets ?? {});
-    const execute = async (job, limit) => {
-        const host = createReplayHost(fixture);
-        try {
-            const result = await executor.run(job, host, {
-                ...(limit !== undefined ? { limit } : {}),
-                ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
-            });
-            return { host, result };
-        }
-        finally {
-            await host.close();
-        }
-    };
-    let main;
-    let declaration = null;
-    let rerun;
-    let error = null;
-    switch (fixtureCase.kind) {
-        case 'pull': {
-            const job = {
-                kind: 'pull', config, secretFields, stream: fixtureCase.stream, mode: fixtureCase.mode, state: fixtureCase.state ?? null,
-                streamConfig: fixtureCase.streamConfig ?? {}, tables: [], discoverFirst: true,
-            };
-            main = await execute(job, fixtureCase.limit);
-            declaration = main.result.declaration;
-            if (fixtureCase.mode === 'full' && main.result.error === null)
-                rerun = (await execute(job, fixtureCase.limit)).result;
-            break;
-        }
-        case 'push': {
-            const discovered = await execute({ kind: 'discover', config, secretFields });
-            if (discovered.result.error) {
-                main = discovered;
-                error = { ...discovered.result.error, message: `discover failed before replaying the push requests: ${discovered.result.error.message}` };
-                break;
-            }
-            declaration = discovered.result.declaration;
-            main = await execute({
-                kind: 'push', config, secretFields,
-                requests: fixture.requests.map((request) => ({ ...request, headers: { ...request.headers }, push: fixtureCase.push })),
-            });
-            break;
-        }
-        case 'discover':
-            main = await execute({ kind: 'discover', config, secretFields });
-            declaration = main.result.declaration;
-            break;
-    }
-    const result = main.result;
-    error ??= result.error;
-    const findings = [];
-    for (const item of main.host.mismatches()) {
-        findings.push({ code: 'FIXTURE_EXCHANGE_MISMATCH', message: `no recorded exchange matches ${item.method} ${item.detail}`, detail: item });
-    }
-    if (error === null) {
-        for (const exchange of main.host.unused()) {
-            findings.push({
-                code: 'FIXTURE_EXCHANGE_UNUSED',
-                message: `recorded exchange ${exchange.seq} (${exchange.kind} ${exchangeSummary(exchange)}) was not used`,
-                detail: { seq: exchange.seq, kind: exchange.kind },
-            });
-        }
-        findings.push(...checkCompliance({
-            declaration, ...scopeOf(fixtureCase), ...(fixtureCase.kind === 'pull' ? { mode: fixtureCase.mode } : {}), result, ...(rerun ? { rerun } : {}),
-        }));
-        findings.push(...checkExpectation(fixture, result, declaration));
-    }
-    return {
-        name: fixture.name,
-        ok: error === null && findings.every((finding) => finding.code === 'FIXTURE_EXCHANGE_UNUSED'),
-        findings,
-        stats: { records: countBy(result.records), removals: countBy(result.removals), checkpoints: result.checkpoints.length, rejected: result.rejected.length },
-        declaration: toDeclaration(declaration),
-        error,
-    };
-}
-export async function runFixtures(executor, files, options = {}) {
-    const results = [];
-    for (const fixture of parseFixtures(files))
-        results.push(await runFixture(executor, fixture, options));
-    return results;
-}

package/testing/schema.d.ts

@@ -1,13 +0,0 @@
-/**
- * 由记录推断列类型（预览面板的「推断结构」、合规检查共用）。纯函数，不依赖 Node 模块（meta 与 UI 都可能用）。
- */
-export type InferredColumnType = 'string' | 'number' | 'boolean' | 'timestamp' | 'json' | 'null';
-/** ISO-8601 日期时间字符串 → 毫秒时刻；不是时返回 null。只有日期的写法不算（推断为 `string`）。 */
-export declare function parseIsoDateTime(value: string): number | null;
-/** ISO-8601 时间字符串（日期时间，或只有日期）→ 毫秒时刻；断点单调判定用。 */
-export declare function parseIsoInstant(value: string): number | null;
-/**
- * 列 → 推断类型：空值不参与；全是空值为 `'null'`；字符串全是 ISO 日期时间为 `'timestamp'`，混有普通字符串为 `'string'`；
- * 对象 / 数组或多种类型混用为 `'json'`。列按首次出现的顺序。
- */
-export declare function inferRecordSchema(rows: Array<Record<string, unknown>>): Record<string, InferredColumnType>;

package/testing/schema.js

@@ -1,65 +0,0 @@
-const ISO_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}(?::?\d{2})?)?$/i;
-const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
-function validDate(year, month, day) {
-    return month >= 1 && month <= 12 && day >= 1 && day <= new Date(Date.UTC(year, month, 0)).getUTCDate();
-}
-export function parseIsoDateTime(value) {
-    const match = ISO_DATE_TIME.exec(value);
-    if (!match)
-        return null;
-    const [, year, month, day, hour, minute, second, offset] = match;
-    if (!validDate(Number(year), Number(month), Number(day)) || Number(hour) > 23 || Number(minute) > 59 || Number(second ?? '0') > 59)
-        return null;
-    const local = value.slice(0, value.length - (offset?.length ?? 0)).replace(' ', 'T').replace(/(\.\d{3})\d+$/, '$1');
-    let zone = 'Z';
-    if (offset !== undefined && offset.toUpperCase() !== 'Z') {
-        const digits = offset.slice(1).replace(':', '');
-        zone = `${offset[0]}${digits.slice(0, 2)}:${digits.length > 2 ? digits.slice(2) : '00'}`;
-    }
-    const parsed = Date.parse(`${local}${zone}`);
-    return Number.isNaN(parsed) ? null : parsed;
-}
-export function parseIsoInstant(value) {
-    const dateTime = parseIsoDateTime(value);
-    if (dateTime !== null)
-        return dateTime;
-    const match = ISO_DATE.exec(value);
-    if (!match || !validDate(Number(match[1]), Number(match[2]), Number(match[3])))
-        return null;
-    return Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
-}
-function kindOf(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value === 'number' || typeof value === 'bigint')
-        return 'number';
-    if (typeof value === 'boolean')
-        return 'boolean';
-    if (typeof value === 'string')
-        return parseIsoDateTime(value) !== null ? 'timestamp' : 'string';
-    return 'json';
-}
-export function inferRecordSchema(rows) {
-    const seen = new Map();
-    for (const row of rows) {
-        for (const [column, value] of Object.entries(row)) {
-            const kinds = seen.get(column) ?? new Set();
-            const kind = kindOf(value);
-            if (kind)
-                kinds.add(kind);
-            seen.set(column, kinds);
-        }
-    }
-    const schema = {};
-    for (const [column, kinds] of seen) {
-        if (kinds.size === 0)
-            schema[column] = 'null';
-        else if (kinds.size === 1)
-            schema[column] = [...kinds][0] ?? 'json';
-        else if (kinds.size === 2 && kinds.has('string') && kinds.has('timestamp'))
-            schema[column] = 'string';
-        else
-            schema[column] = 'json';
-    }
-    return schema;
-}

package/testing/source-loader.d.ts

@@ -1,19 +0,0 @@
-export interface LoadedSource {
-    name: string;
-    version: string;
-    /** CommonJS 打包串，交给 guest 会话的 `execute.code`。 */
-    code: string;
-    /** 索引映射形式的 sourcemap（JSON 文本），`sources` 为相对源码根目录的路径。 */
-    sourcemap: string;
-    /** 源码文件（相对路径 → 文本，不含 `fixtures/`）。 */
-    files: Record<string, string>;
-    /** `dependencies` 里 SDK 的写法（版本范围或 `file:` 路径），由调用方按共享规则校验。 */
-    sdkRange: string;
-}
-/** 与 shared `connector-limits.ts` 同值。 */
-export declare const LOCAL_SOURCE_MAX_BYTES: number;
-export declare const LOCAL_SOURCE_MAX_FILES = 200;
-/** 读取并转译一个连接器源码目录。`options.typescript` 是项目自己的 TypeScript 编译器 API（`import ts from 'typescript'`）。 */
-export declare function loadConnectorSource(dir: string, options: {
-    typescript: unknown;
-}): Promise<LoadedSource>;

package/testing/source-loader.js

@@ -1,238 +0,0 @@
-import { lstat, readdir, readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { asTypeScript, classifySpecifier, collectRequires, collectSourceSpecifiers, CONNECTOR_SDK_SPECIFIER, findForbiddenSourceSyntax, } from './import-guard.js';
-import { SourceLoadError } from './types.js';
-export const LOCAL_SOURCE_MAX_BYTES = 2 * 1024 * 1024;
-export const LOCAL_SOURCE_MAX_FILES = 200;
-const EXCLUDED_DIRECTORIES = new Set(['node_modules', '.git', 'dist', '.ontos', '.datasense']);
-const FIXTURES_DIRECTORY = 'fixtures';
-const DEFAULT_MAIN = 'src/index.ts';
-const NAME_PATTERN = /^[a-z][a-z0-9_]{0,27}$/;
-const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
-const CODE_FILE = /\.[cm]?[jt]sx?$/;
-const RESOLVE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'];
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-async function collectFiles(root) {
-    const files = {};
-    let count = 0;
-    let bytes = 0;
-    const visit = async (absolute, relative) => {
-        const entries = await readdir(absolute, { withFileTypes: true });
-        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-        for (const entry of entries) {
-            const childRelative = relative ? `${relative}/${entry.name}` : entry.name;
-            const excluded = EXCLUDED_DIRECTORIES.has(entry.name) || (relative === '' && entry.name === FIXTURES_DIRECTORY);
-            if (excluded && (entry.isDirectory() || entry.isSymbolicLink()))
-                continue;
-            if (entry.isSymbolicLink()) {
-                throw new SourceLoadError('SYMLINK', `symbolic links are not supported in connector source: ${childRelative}`, childRelative);
-            }
-            if (entry.isDirectory()) {
-                await visit(path.join(absolute, entry.name), childRelative);
-            }
-            else if (entry.isFile()) {
-                count += 1;
-                if (count > LOCAL_SOURCE_MAX_FILES) {
-                    throw new SourceLoadError('TOO_LARGE', `connector source has more than ${LOCAL_SOURCE_MAX_FILES} files`);
-                }
-                const text = await readFile(path.join(absolute, entry.name), 'utf8');
-                bytes += Buffer.byteLength(text, 'utf8');
-                if (bytes > LOCAL_SOURCE_MAX_BYTES) {
-                    throw new SourceLoadError('TOO_LARGE', `connector source exceeds ${LOCAL_SOURCE_MAX_BYTES} bytes`);
-                }
-                files[childRelative] = text;
-            }
-        }
-    };
-    await visit(root, '');
-    return files;
-}
-function readManifest(files) {
-    const text = files['package.json'];
-    if (text === undefined)
-        throw new SourceLoadError('MANIFEST_INVALID', 'package.json is missing', 'package.json');
-    let pkg;
-    try {
-        pkg = JSON.parse(text);
-    }
-    catch {
-        throw new SourceLoadError('MANIFEST_INVALID', 'package.json is not valid JSON', 'package.json');
-    }
-    if (!isRecord(pkg))
-        throw new SourceLoadError('MANIFEST_INVALID', 'package.json must be a JSON object', 'package.json');
-    const invalid = (message) => new SourceLoadError('MANIFEST_INVALID', message, 'package.json');
-    if (typeof pkg.name !== 'string' || !NAME_PATTERN.test(pkg.name))
-        throw invalid(`name must match ${NAME_PATTERN.source}`);
-    if (typeof pkg.version !== 'string' || !VERSION_PATTERN.test(pkg.version))
-        throw invalid('version must be a semver string like 1.0.0');
-    let main = DEFAULT_MAIN;
-    if (pkg.main !== undefined) {
-        if (typeof pkg.main !== 'string')
-            throw invalid('main must be a string');
-        main = path.posix.normalize(pkg.main.startsWith('./') ? pkg.main.slice(2) : pkg.main);
-        if (main.startsWith('/') || main === '..' || main.startsWith('../')) {
-            throw new SourceLoadError('PATH_ESCAPE', `main escapes the connector source root: ${pkg.main}`, 'package.json');
-        }
-    }
-    if (!CODE_FILE.test(main))
-        throw invalid(`main must be a .ts or .js file: ${main}`);
-    if (files[main] === undefined)
-        throw invalid(`entry file not found: ${main}`);
-    const dependencies = pkg.dependencies;
-    if (!isRecord(dependencies))
-        throw invalid(`dependencies must list ${CONNECTOR_SDK_SPECIFIER}`);
-    for (const dependency of Object.keys(dependencies)) {
-        if (dependency !== CONNECTOR_SDK_SPECIFIER)
-            throw invalid(`connectors can only depend on ${CONNECTOR_SDK_SPECIFIER}, found ${dependency}`);
-    }
-    const sdkRange = dependencies[CONNECTOR_SDK_SPECIFIER];
-    if (typeof sdkRange !== 'string' || sdkRange.length === 0)
-        throw invalid(`dependencies must list ${CONNECTOR_SDK_SPECIFIER}`);
-    return { name: pkg.name, version: pkg.version, main, sdkRange };
-}
-function resolveModule(files, target) {
-    const base = target === '.' ? 'index' : target;
-    const candidates = [base, ...RESOLVE_EXTENSIONS.map((ext) => `${base}${ext}`), ...RESOLVE_EXTENSIONS.map((ext) => `${base}/index${ext}`)];
-    for (const candidate of candidates) {
-        if (Object.hasOwn(files, candidate) && (CODE_FILE.test(candidate) || candidate.endsWith('.json')))
-            return candidate;
-    }
-    return null;
-}
-const SOURCE_MAP_COMMENT = /\n?\/\/# sourceMappingURL=[^\n]*\s*$/;
-function transpile(ts, id, content) {
-    const output = ts.transpileModule(content, {
-        fileName: id,
-        reportDiagnostics: false,
-        compilerOptions: {
-            module: ts.ModuleKind.CommonJS,
-            target: ts.ScriptTarget.ES2022,
-            esModuleInterop: true,
-            sourceMap: true,
-            inlineSourceMap: false,
-            inlineSources: true,
-            jsx: ts.JsxEmit.React,
-        },
-    });
-    const code = output.outputText.replace(SOURCE_MAP_COMMENT, '');
-    let map = { version: 3, sources: [id], names: [], mappings: '' };
-    if (output.sourceMapText) {
-        const parsed = JSON.parse(output.sourceMapText);
-        map = { ...parsed, sources: [id], sourceRoot: '' };
-        delete map.file;
-    }
-    return { code, map };
-}
-function loadModule(ts, files, id) {
-    const content = files[id] ?? '';
-    if (id.endsWith('.json')) {
-        try {
-            JSON.parse(content);
-        }
-        catch (error) {
-            throw new SourceLoadError('SYNTAX_ERROR', `${id} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, id);
-        }
-        return { id, body: `module.exports = JSON.parse(${JSON.stringify(content)});`, map: null, requires: {} };
-    }
-    const problems = findForbiddenSourceSyntax(ts, id, content);
-    const syntax = problems.find((problem) => problem.kind === 'syntax');
-    if (syntax)
-        throw new SourceLoadError('SYNTAX_ERROR', `${id}:${syntax.line}:${syntax.column + 1} ${syntax.message}`, id);
-    const forbidden = problems[0];
-    if (forbidden)
-        throw new SourceLoadError('IMPORT_FORBIDDEN', `${id}:${forbidden.line}:${forbidden.column + 1} ${forbidden.message}`, id);
-    for (const entry of collectSourceSpecifiers(ts, id, content)) {
-        const kind = classifySpecifier(entry.specifier, id);
-        if (kind.kind === 'escape')
-            throw new SourceLoadError('PATH_ESCAPE', `${id}:${entry.line} import '${entry.specifier}' escapes the connector source root`, id);
-        if (kind.kind === 'forbidden')
-            throw new SourceLoadError('IMPORT_FORBIDDEN', `${id}:${entry.line} ${kind.message}`, id);
-    }
-    const { code, map } = transpile(ts, id, content);
-    const requires = {};
-    for (const entry of collectRequires(ts, id, code)) {
-        if (entry.specifier === null) {
-            throw new SourceLoadError('IMPORT_FORBIDDEN', `${id}: imports must use a literal path (computed require / import() is not allowed)`, id);
-        }
-        const specifier = entry.specifier;
-        if (Object.hasOwn(requires, specifier))
-            continue;
-        const kind = classifySpecifier(specifier, id);
-        switch (kind.kind) {
-            case 'sdk':
-                requires[specifier] = null;
-                break;
-            case 'escape':
-                throw new SourceLoadError('PATH_ESCAPE', `${id}: import '${specifier}' escapes the connector source root`, id);
-            case 'forbidden':
-                throw new SourceLoadError('IMPORT_FORBIDDEN', `${id}: ${kind.message}`, id);
-            case 'relative': {
-                const resolved = resolveModule(files, kind.target);
-                if (resolved === null)
-                    throw new SourceLoadError('IMPORT_FORBIDDEN', `${id}: cannot resolve import '${specifier}'`, id);
-                requires[specifier] = resolved;
-                break;
-            }
-        }
-    }
-    return { id, body: code, map, requires };
-}
-function countLines(text) {
-    let lines = 0;
-    for (let i = 0; i < text.length; i += 1)
-        if (text.charCodeAt(i) === 10)
-            lines += 1;
-    return lines;
-}
-function assemble(modules, entry) {
-    const lines = ['var __ontosModules = {'];
-    const sections = [];
-    let line = 1;
-    for (const module of modules) {
-        lines.push(`${JSON.stringify(module.id)}: [${JSON.stringify(module.requires)}, function (module, exports, require) {`);
-        line += 1;
-        if (module.map)
-            sections.push({ offset: { line, column: 0 }, map: module.map });
-        const body = module.body.endsWith('\n') ? module.body.slice(0, -1) : module.body;
-        lines.push(body);
-        line += countLines(body) + 1;
-        lines.push('}],');
-        line += 1;
-    }
-    lines.push('};', 'var __ontosCache = {};', 'function __ontosRequire(id) {', '  var cached = __ontosCache[id];', '  if (cached) return cached.exports;', '  var entry = __ontosModules[id];', '  var mod = { exports: {} };', '  __ontosCache[id] = mod;', '  var table = entry[0];', '  entry[1].call(mod.exports, mod, mod.exports, function (specifier) {', '    if (!Object.prototype.hasOwnProperty.call(table, specifier)) throw new Error("cannot require " + String(specifier) + " from " + id);', '    var target = table[specifier];', '    return target === null ? require(specifier) : __ontosRequire(target);', '  });', '  return mod.exports;', '}', `module.exports = __ontosRequire(${JSON.stringify(entry)});`);
-    return {
-        code: lines.join('\n'),
-        sourcemap: JSON.stringify({ version: 3, file: 'connector.js', sections }),
-    };
-}
-export async function loadConnectorSource(dir, options) {
-    const ts = asTypeScript(options.typescript);
-    const root = path.resolve(dir);
-    const stat = await lstat(root).catch(() => null);
-    if (!stat)
-        throw new SourceLoadError('MANIFEST_INVALID', `connector source directory not found: ${dir}`);
-    if (stat.isSymbolicLink())
-        throw new SourceLoadError('SYMLINK', `the connector source directory is a symbolic link: ${dir}`);
-    if (!stat.isDirectory())
-        throw new SourceLoadError('MANIFEST_INVALID', `not a directory: ${dir}`);
-    const files = await collectFiles(root);
-    const manifest = readManifest(files);
-    const modules = [];
-    const seen = new Set();
-    const queue = [manifest.main];
-    while (queue.length > 0) {
-        const id = queue.shift();
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        const module = loadModule(ts, files, id);
-        modules.push(module);
-        for (const target of Object.values(module.requires))
-            if (target !== null && !seen.has(target))
-                queue.push(target);
-    }
-    const { code, sourcemap } = assemble(modules, manifest.main);
-    return { name: manifest.name, version: manifest.version, code, sourcemap, files, sdkRange: manifest.sdkRange };
-}