@gobing-ai/ts-llm-jsonl-importer 0.5.11 → 0.5.12

package/README.md

@@ -219,6 +219,50 @@ The custom `source` name flows through checkpoints, the ledger, and `ImportResul
 like a built-in key. The importer creates the target ETL table on demand if it does not exist
 (idempotent `CREATE TABLE IF NOT EXISTS`), so built-in tables are unaffected.
 
+## Skill-Call Capability Facts (E93)
+
+`history_skill_call` classifies every observed skill invocation with four nullable facts plus a
+stable identity:
+
+- `invocation_id` — content-hash identity over `(source, session, kind, id, ordinal, file, line)`;
+  correlated representations of one invocation (e.g. a codex `$skill` marker plus its companion
+  `<skill>` block) share one id.
+- `capability_kind` — `skill`, `command`, or `subagent` — where the invocation's target artifact
+  was resolved to (native classification first, then a unique supplied origin; `NULL` when unknown).
+- `origin_identity` — the origin index identity for the resolved artifact.
+- `evidence_kind` — `load` (skill observed executing/loaded), `request` (command spelled by the
+  user), or `delegation` (agent-to-agent subagent dispatch).
+- `status` — `unknown` until a paired tool result rides the row (`ok`/`error`) or the harness
+  wrapper itself is the verified injection.
+
+Capability classification never infers from name spelling alone: a `$sp-dev-run` marker without a
+matching command record or skill block classifies as unknown. Pass a verified origin index to make
+resolved origins part of the import contract (invalid entries reject the run before any write):
+
+```ts
+const result = await runJsonlImport('codex', {
+    db,
+    files,
+    mode: 'incremental',
+    capabilityOrigins: [
+        {
+            source: 'codex',
+            skillName: 'sp:dev-run',
+            skillPath: '/skills/sp-dev-run/SKILL.md',
+            artifactDigest: sha256Text(body.trim()),
+            capabilityKind: 'skill',
+            originIdentity: 'sp/src/skills/dev-run',
+        },
+    ],
+});
+```
+
+Digest mismatches and conflicting origin entries never cause a silent guess: the row classifies as
+unknown and the run reports a bounded, deduplicated validation finding. Shell reads of `SKILL.md`
+files (`cat`, `sed -n '<range>p'`) inside tool payloads — including nested
+`tools.exec_command({cmd: ...})` literals — surface as implicit loads. Results may arrive in a later
+incremental run; pairing falls back to the database and upgrades the existing row in place.
+
 ## Boundary Notes
 
 - This package imports JSONL files and writes importer-owned tables; it does not model conversations, turns, tool calls, or analytics semantics.

package/dist/capability.d.ts

@@ -0,0 +1,52 @@
+import type { CapabilityOrigin } from './types';
+/** Result of matching a record's observable identity against the supplied origin index. */
+export interface CapabilityOriginMatch {
+    /** The unique agreeing origin, or null when nothing agreed. */
+    readonly origin: CapabilityOrigin | undefined;
+    /** Human-readable conflict reason when candidate origins disagreed (never a guess). */
+    readonly conflict: string | null;
+}
+/** Validate operator-supplied capability origins before the importer opens any write path. */
+export declare function validateCapabilityOrigins(input: readonly CapabilityOrigin[] | undefined): readonly CapabilityOrigin[];
+/**
+ * Match one invoking record against the supplied origin index for its source.
+ *
+ * Agreement is required on every observable dimension: canonical name always; exact path
+ * when the record observed one; complete-artifact digest when the record carried the full
+ * injected body. Name+path narrowing first, then digest filtering; zero matches resolve to
+ * unknown (no origin), more than one to a conflict. Pure — no persistence.
+ */
+export declare function matchCapabilityOrigin(origins: readonly CapabilityOrigin[], source: string, canonicalName: string, observable: {
+    skillPath?: string | null;
+    artifactDigest?: string | null;
+}): CapabilityOriginMatch;
+/** Stable version-1 invocation-identity tuple → `invocation_id` (E93 §8.2). */
+export declare function capabilityInvocationId(parts: {
+    source: string;
+    sessionId: string;
+    kind: 'invocation' | 'call' | 'record' | 'line';
+    id?: string;
+    ordinal?: number;
+    file?: string;
+    line?: number;
+}): string;
+/**
+ * Extract SKILL.md read targets from one literal shell command (E93 §8.2).
+ *
+ * Accepts only literal `cat [-n...] [--] <path...>` and `sed -n <range>... <path>` forms
+ * whose final segment resolves to a `SKILL.md` file. Expansions (`$`, backticks, escapes),
+ * redirections, multiple commands per argument and anything non-literal yield no targets.
+ */
+export declare function parseLiteralReadTargets(command: string): readonly string[];
+/**
+ * Extract literal command strings from nested `tools.exec_command({cmd: <literal>, ...})`
+ * payloads (E93 §8.2 — codex `functions.exec` bodies).
+ *
+ * Strict shape: `cmd` as the first key with a plain single/double-quoted string literal;
+ * any further keys must be plain literals; no template literals, concatenation or
+ * expansions. Matches must start a statement (after whitespace, `{`, `;` or `}`) so the
+ * same text quoted inside a larger string is not code; whole-line and block comments are
+ * skipped.
+ */
+export declare function extractNestedExecCommandLiterals(payloadText: string): readonly string[];
+//# sourceMappingURL=capability.d.ts.map

package/dist/capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability.d.ts","sourceRoot":"","sources":["../src/capability.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAkB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhE,2FAA2F;AAC3F,MAAM,WAAW,qBAAqB;IAClC,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC9C,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAKD,8FAA8F;AAC9F,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,GAAG,SAAS,gBAAgB,EAAE,CAqCrH;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACjC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC1E,qBAAqB,CA4BvB;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;IAChD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CA2BT;AA6HD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CA+C1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,gCAAgC,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CA2CvF"}

package/dist/capability.js

@@ -0,0 +1,365 @@
+/**
+ * Capability-origin classification helpers (E93 task 1028).
+ *
+ * Pure helpers shared by the per-source skill-call detectors in `./mappers` and validated
+ * at the importer boundary. Two responsibilities:
+ *
+ * 1. **Origin matching** — a `history_skill_call` row's `capability_kind`/`origin_identity`
+ *    is established by (a) native source identity (a command expansion envelope, a native
+ *    command record, a delegation record) or (b) a unique supplied {@link CapabilityOrigin}
+ *    whose source, canonical name, optional exact path and observed complete-artifact
+ *    digest agree with the invoking record. Never from a name prefix, invocation
+ *    restriction or marker spelling alone; conflicts classify as unknown and surface a
+ *    bounded finding rather than guessing.
+ * 2. **Bounded literal grammars** — shell `cat [--] <path...>` / `sed -n '<range>p' <path>`
+ *    read commands and nested `tools.exec_command({cmd: <literal>})` payloads are parsed as
+ *    strict literal shapes only: quote-honoring, comment/quoted-code aware, rejecting
+ *    expansions, substitutions and redirections. Anything outside the grammar yields no
+ *    capability fact (an ordinary tool call), never a guess.
+ */
+import { HistoryImportError } from './errors.js';
+import { sha256Text } from './hash.js';
+const CAPABILITY_KINDS = ['command', 'subagent', 'skill'];
+const DIGEST_PATTERN = /^[0-9a-f]{64}$/;
+/** Validate operator-supplied capability origins before the importer opens any write path. */
+export function validateCapabilityOrigins(input) {
+    if (input === undefined)
+        return [];
+    if (!Array.isArray(input)) {
+        throw new HistoryImportError('capabilityOrigins must be an array of CapabilityOrigin objects.', {
+            option: 'capabilityOrigins',
+        });
+    }
+    return input.map((origin, index) => {
+        const fail = (reason) => {
+            throw new HistoryImportError(`capabilityOrigins[${index}]: ${reason}`, {
+                option: 'capabilityOrigins',
+                index,
+            });
+        };
+        if (typeof origin !== 'object' || origin === null)
+            fail('entry must be an object.');
+        if (typeof origin.source !== 'string' || origin.source.trim() === '')
+            fail('source must be a non-empty string.');
+        if (typeof origin.skillName !== 'string' || origin.skillName.trim() === '') {
+            fail('skillName must be a non-empty string.');
+        }
+        if (typeof origin.artifactDigest !== 'string' || !DIGEST_PATTERN.test(origin.artifactDigest)) {
+            fail('artifactDigest must be a 64-character lowercase hex SHA-256 string.');
+        }
+        if (!CAPABILITY_KINDS.includes(origin.capabilityKind)) {
+            fail(`capabilityKind must be one of ${CAPABILITY_KINDS.map((k) => `'${k}'`).join(', ')}.`);
+        }
+        if (typeof origin.originIdentity !== 'string' || origin.originIdentity.trim() === '') {
+            fail('originIdentity must be a non-empty string.');
+        }
+        if (origin.skillPath !== undefined &&
+            (typeof origin.skillPath !== 'string' || origin.skillPath.trim() === '')) {
+            fail('skillPath must be a non-empty string when present.');
+        }
+        return origin;
+    });
+}
+/**
+ * Match one invoking record against the supplied origin index for its source.
+ *
+ * Agreement is required on every observable dimension: canonical name always; exact path
+ * when the record observed one; complete-artifact digest when the record carried the full
+ * injected body. Name+path narrowing first, then digest filtering; zero matches resolve to
+ * unknown (no origin), more than one to a conflict. Pure — no persistence.
+ */
+export function matchCapabilityOrigin(origins, source, canonicalName, observable) {
+    let candidates = origins.filter((origin) => origin.source === source && origin.skillName === canonicalName);
+    if (candidates.length === 0)
+        return { origin: undefined, conflict: null };
+    if (observable.skillPath != null && observable.skillPath !== '') {
+        const byPath = candidates.filter((origin) => origin.skillPath !== undefined && origin.skillPath === observable.skillPath);
+        if (byPath.length > 0)
+            candidates = byPath;
+    }
+    if (observable.artifactDigest != null && observable.artifactDigest !== '') {
+        const byDigest = candidates.filter((origin) => origin.artifactDigest === observable.artifactDigest);
+        if (byDigest.length === 1)
+            return { origin: byDigest[0], conflict: null };
+        if (byDigest.length > 1) {
+            return {
+                origin: undefined,
+                conflict: `capabilityOrigins: ${byDigest.length} origins agree on digest for '${canonicalName}'.`,
+            };
+        }
+        return {
+            origin: undefined,
+            conflict: `capabilityOrigins: observed artifact digest does not match the supplied origin for '${canonicalName}'.`,
+        };
+    }
+    if (candidates.length === 1)
+        return { origin: candidates[0], conflict: null };
+    return {
+        origin: undefined,
+        conflict: `capabilityOrigins: ${candidates.length} origins match '${canonicalName}' without distinguishing evidence.`,
+    };
+}
+/** Stable version-1 invocation-identity tuple → `invocation_id` (E93 §8.2). */
+export function capabilityInvocationId(parts) {
+    return sha256Text(JSON.stringify({
+        domain: 'capability-invocation',
+        v: 1,
+        source: parts.source,
+        sessionId: parts.sessionId,
+        kind: parts.kind,
+        id: parts.id ?? null,
+        ordinal: parts.ordinal ?? null,
+        file: parts.file ?? null,
+        line: parts.line ?? null,
+    }, Object.keys({
+        domain: 0,
+        v: 0,
+        source: 0,
+        sessionId: 0,
+        kind: 0,
+        id: 0,
+        ordinal: 0,
+        file: 0,
+        line: 0,
+    }).sort()));
+}
+/**
+ * Tokenize one command segment honoring single/double quotes. Inside double quotes,
+ * `$`/backtick mark the whole segment dynamic (expansion). Backslash escapes outside
+ * quotes mark it dynamic too — the bounded grammar only trusts plain literals.
+ */
+function scanShellSegment(segment) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    let dynamic = false;
+    for (let i = 0; i < segment.length; i += 1) {
+        const ch = segment[i];
+        if (quote === "'") {
+            if (ch === "'")
+                quote = null;
+            else
+                current += ch;
+            continue;
+        }
+        if (quote === '"') {
+            if (ch === '"')
+                quote = null;
+            else if (ch === '$' || ch === '`')
+                dynamic = true;
+            else
+                current += ch;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            continue;
+        }
+        if (ch === '\\' || ch === '$' || ch === '`') {
+            dynamic = true;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\n') {
+            if (current !== '')
+                tokens.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (quote !== null)
+        dynamic = true; // unterminated quote — torn or foreign line
+    if (current !== '')
+        tokens.push(current);
+    return { tokens, dynamic };
+}
+/** Split a command string into segments at top-level `&&`, `||`, `;` and `|` separators. */
+function splitShellSegments(command) {
+    const segments = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (quote !== null) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === ';') {
+            segments.push(current);
+            current = '';
+            continue;
+        }
+        if (ch === '|' || ch === '&') {
+            if (command[i + 1] === ch) {
+                segments.push(current);
+                current = '';
+                i += 1;
+                continue;
+            }
+            segments.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    segments.push(current);
+    return segments;
+}
+/** Final path segment of a candidate read target, or null. */
+function lastPathSegment(path) {
+    const trimmed = path.replace(/\/+$/, '');
+    const idx = trimmed.lastIndexOf('/');
+    return idx === -1 ? trimmed : trimmed.slice(idx + 1);
+}
+/** A `sed -n` arg is a print range only when it is a pure line-address print form. */
+function isSedPrintRange(token) {
+    return /^\$?[0-9]+(\s*,\s*(\$|[0-9]+))?p$/.test(token) || /^\$p$/.test(token);
+}
+/** Does a segment contain a redirection operator outside quotes? */
+function hasRedirection(segment) {
+    let quote = null;
+    for (let i = 0; i < segment.length; i += 1) {
+        const ch = segment[i];
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            continue;
+        }
+        if (ch === '>' || ch === '<')
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract SKILL.md read targets from one literal shell command (E93 §8.2).
+ *
+ * Accepts only literal `cat [-n...] [--] <path...>` and `sed -n <range>... <path>` forms
+ * whose final segment resolves to a `SKILL.md` file. Expansions (`$`, backticks, escapes),
+ * redirections, multiple commands per argument and anything non-literal yield no targets.
+ */
+export function parseLiteralReadTargets(command) {
+    if (typeof command !== 'string' || command.trim() === '')
+        return [];
+    const targets = [];
+    for (const segment of splitShellSegments(command)) {
+        if (segment.trim() === '' || hasRedirection(segment))
+            continue;
+        const trimmed = segment.trim();
+        if (trimmed.startsWith('#'))
+            continue; // comment line
+        const scan = scanShellSegment(trimmed);
+        if (scan.dynamic || scan.tokens.length === 0)
+            continue;
+        const [cmd, ...args] = scan.tokens;
+        if (cmd === 'cat') {
+            for (const arg of args) {
+                if (arg === '--')
+                    continue; // end-of-options marker is literal-safe
+                if (arg.startsWith('-'))
+                    continue; // options like -n
+                if (lastPathSegment(arg) === 'SKILL.md')
+                    targets.push(arg);
+            }
+            continue;
+        }
+        if (cmd === 'sed') {
+            let sawNoPrint = false;
+            const rangeArgs = [];
+            for (const arg of args) {
+                if (arg === '--')
+                    continue;
+                if (arg === '-n' || arg === '--quiet' || arg === '--silent') {
+                    sawNoPrint = true;
+                    continue;
+                }
+                if (arg.startsWith('-')) {
+                    sawNoPrint = false; // any other flag leaves the bounded print form
+                    break;
+                }
+                if (isSedPrintRange(arg)) {
+                    rangeArgs.push(arg);
+                    continue;
+                }
+                // First non-range non-flag arg: the path. Exactly one, after ranges.
+                if (rangeArgs.length === 0) {
+                    sawNoPrint = false;
+                    break;
+                }
+                if (lastPathSegment(arg) === 'SKILL.md')
+                    targets.push(arg);
+                break; // only one path per sed invocation
+            }
+            if (!sawNoPrint)
+                continue;
+        }
+    }
+    return targets;
+}
+/**
+ * Extract literal command strings from nested `tools.exec_command({cmd: <literal>, ...})`
+ * payloads (E93 §8.2 — codex `functions.exec` bodies).
+ *
+ * Strict shape: `cmd` as the first key with a plain single/double-quoted string literal;
+ * any further keys must be plain literals; no template literals, concatenation or
+ * expansions. Matches must start a statement (after whitespace, `{`, `;` or `}`) so the
+ * same text quoted inside a larger string is not code; whole-line and block comments are
+ * skipped.
+ */
+export function extractNestedExecCommandLiterals(payloadText) {
+    if (typeof payloadText !== 'string' || payloadText.trim() === '')
+        return [];
+    const literals = [];
+    const shape = /tools\.exec_command\(\s*\{\s*cmd:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')((?:\s*,\s*[A-Za-z_][A-Za-z0-9_]*\s*:\s*(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[-0-9.eE+]+|true|false|null))*)\s*\}\s*\)/g;
+    let inBlockComment = false;
+    for (const rawLine of payloadText.split(/\r?\n/)) {
+        let line = rawLine;
+        if (inBlockComment) {
+            const end = line.indexOf('*/');
+            if (end === -1)
+                continue;
+            line = line.slice(end + 2);
+            inBlockComment = false;
+        }
+        // Strip whole-line comments; a line that opens a block comment contributes only its prefix.
+        const trimmedStart = line.trimStart();
+        if (trimmedStart.startsWith('//'))
+            continue;
+        const blockStart = line.indexOf('/*');
+        if (blockStart !== -1) {
+            const end = line.indexOf('*/', blockStart + 2);
+            line = end === -1 ? line.slice(0, blockStart) : line.slice(0, blockStart) + line.slice(end + 2);
+            if (end === -1)
+                inBlockComment = true;
+        }
+        const statementStart = /(?:^|[{};]\s*)$/; // match must follow whitespace or a statement boundary
+        shape.lastIndex = 0;
+        let match = shape.exec(line);
+        while (match !== null) {
+            const before = line.slice(0, match.index);
+            if (statementStart.test(before)) {
+                const literal = match[1] ?? '';
+                const quote = literal[0] ?? '"';
+                const body = literal
+                    .slice(1, -1)
+                    .replaceAll(`\\${quote}`, quote)
+                    .replaceAll('\\\\', '\\')
+                    .replaceAll('\\n', '\n')
+                    .replaceAll('\\t', '\t');
+                literals.push(body);
+            }
+            match = shape.exec(line);
+        }
+    }
+    return literals;
+}

package/dist/hash.d.ts

@@ -2,4 +2,13 @@
 export declare function stableJson(value: unknown): string;
 /** Compute a SHA-256 hash for an already-normalized record. */
 export declare function sha256(value: unknown): string;
+/**
+ * SHA-256 over the raw UTF-8 bytes of a string (E93 task 1028).
+ *
+ * Distinct from {@link sha256}, which hashes the *stable-JSON encoding* of a value:
+ * artifact digests must be computed over the exact observed artifact bytes so a
+ * supplied {@link CapabilityOrigin} digest recorded from the real file matches the
+ * digest observed in a transcript wrapper.
+ */
+export declare function sha256Text(text: string): string;
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAEA,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAajD;AAED,+DAA+D;AAC/D,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7C"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAEA,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAajD;AAED,+DAA+D;AAC/D,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7C;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/dist/hash.js

@@ -18,3 +18,14 @@ export function stableJson(value) {
 export function sha256(value) {
     return createHash('sha256').update(stableJson(value)).digest('hex');
 }
+/**
+ * SHA-256 over the raw UTF-8 bytes of a string (E93 task 1028).
+ *
+ * Distinct from {@link sha256}, which hashes the *stable-JSON encoding* of a value:
+ * artifact digests must be computed over the exact observed artifact bytes so a
+ * supplied {@link CapabilityOrigin} digest recorded from the real file matches the
+ * digest observed in a transcript wrapper.
+ */
+export function sha256Text(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex');
+}

package/dist/importer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"importer.d.ts","sourceRoot":"","sources":["../src/importer.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAER,aAAa,EACb,YAAY,EAGZ,gBAAgB,EAEnB,MAAM,SAAS,CAAC;AAqFjB;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA8ZrH"}
+{"version":3,"file":"importer.d.ts","sourceRoot":"","sources":["../src/importer.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAER,aAAa,EACb,YAAY,EAGZ,gBAAgB,EAEnB,MAAM,SAAS,CAAC;AA4JjB;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAoerH"}