@ironbee-ai/cli 0.6.2 → 0.7.1

package/dist/import/emitter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * IronBee CLI — Import Module Direct Collector POST
+ *
+ * Thin wrapper around `lib/collector.ts:sendEventsBatchToCollector` with
+ * transient-failure retry (1s/4s/16s backoff ).
+ * Never touches `actions.jsonl`, the queue, or any session state writers.
+ *
+ * Per-event-type batching: events of mixed types are POSTed in a single
+ * batch (the collector contract is a flat `Event[]`). Caller chunks by
+ * size if desired.
+ */
+import { Event } from "../lib/event";
+import { CollectorTarget } from "../lib/collector";
+export interface EmitterOpts {
+    sessionId: string;
+    projectDir: string;
+    target: CollectorTarget | null;
+    /** Override per-batch cap. Defaults to `target.batchSize` or 100. */
+    batchSize?: number;
+}
+/**
+ * POST a batch of events with retry. Returns when every batch has either
+ * succeeded or exhausted retries. On exhaustion, throws the last error so
+ * the pipeline can mark the session `failed` (per-session atomicity).
+ *
+ * Silent no-op when `target === null` (collector disabled).
+ */
+export declare function postEvents(events: Event[], opts: EmitterOpts): Promise<void>;
+//# sourceMappingURL=emitter.d.ts.map

package/dist/import/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/import/emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,eAAe,EAA8B,MAAM,kBAAkB,CAAC;AAG/E,MAAM,WAAW,WAAW;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAKD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBlF"}

package/dist/import/emitter.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Direct Collector POST
+ *
+ * Thin wrapper around `lib/collector.ts:sendEventsBatchToCollector` with
+ * transient-failure retry (1s/4s/16s backoff ).
+ * Never touches `actions.jsonl`, the queue, or any session state writers.
+ *
+ * Per-event-type batching: events of mixed types are POSTed in a single
+ * batch (the collector contract is a flat `Event[]`). Caller chunks by
+ * size if desired.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postEvents = postEvents;
+const collector_1 = require("../lib/collector");
+const logger_1 = require("../lib/logger");
+const DEFAULT_BATCH_SIZE = 100;
+const RETRY_DELAYS_MS = [1000, 4000, 16000];
+/**
+ * POST a batch of events with retry. Returns when every batch has either
+ * succeeded or exhausted retries. On exhaustion, throws the last error so
+ * the pipeline can mark the session `failed` (per-session atomicity).
+ *
+ * Silent no-op when `target === null` (collector disabled).
+ */
+async function postEvents(events, opts) {
+    if (events.length === 0) {
+        return;
+    }
+    if (opts.target === null) {
+        logger_1.logger.debug(`import emitter: collector disabled — dropping ${events.length} events`);
+        return;
+    }
+    const batchSize = opts.batchSize
+        ?? (typeof opts.target.batchSize === "number" && opts.target.batchSize >= 1
+            ? opts.target.batchSize
+            : DEFAULT_BATCH_SIZE);
+    for (let i = 0; i < events.length; i += batchSize) {
+        const batch = events.slice(i, Math.min(i + batchSize, events.length));
+        await postOneBatchWithRetry(batch, opts);
+    }
+}
+async function postOneBatchWithRetry(batch, opts) {
+    let lastErr = null;
+    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
+        try {
+            await (0, collector_1.sendEventsBatchToCollector)(batch, opts.sessionId, opts.projectDir, opts.target);
+            return;
+        }
+        catch (e) {
+            lastErr = e instanceof Error ? e : new Error(String(e));
+            if (attempt < RETRY_DELAYS_MS.length) {
+                const delay = RETRY_DELAYS_MS[attempt];
+                logger_1.logger.debug(`import emitter: batch send failed (attempt ${attempt + 1}): ${lastErr.message} — retry in ${delay}ms`);
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastErr ?? new Error("import emitter: send failed after retries");
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+//# sourceMappingURL=emitter.js.map

package/dist/import/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../src/import/emitter.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAwBH,gCAiBC;AAtCD,gDAA+E;AAC/E,0CAAuC;AAUvC,MAAM,kBAAkB,GAAW,GAAG,CAAC;AACvC,MAAM,eAAe,GAAa,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AAEtD;;;;;;GAMG;AACI,KAAK,UAAU,UAAU,CAAC,MAAe,EAAE,IAAiB;IAC/D,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO;IACX,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QACvB,eAAM,CAAC,KAAK,CAAC,iDAAiD,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC;QACtF,OAAO;IACX,CAAC;IACD,MAAM,SAAS,GAAW,IAAI,CAAC,SAAS;WACjC,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC;YACvE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS;YACvB,CAAC,CAAC,kBAAkB,CAAC,CAAC;IAE9B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,SAAS,EAAE,CAAC;QACxD,MAAM,KAAK,GAAY,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAC/E,MAAM,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;AACL,CAAC;AAED,KAAK,UAAU,qBAAqB,CAAC,KAAc,EAAE,IAAiB;IAClE,IAAI,OAAO,GAAiB,IAAI,CAAC;IACjC,KAAK,IAAI,OAAO,GAAW,CAAC,EAAE,OAAO,IAAI,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC;QACzE,IAAI,CAAC;YACD,MAAM,IAAA,sCAA0B,EAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YACtF,OAAO;QACX,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YAClB,OAAO,GAAG,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACxD,IAAI,OAAO,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC;gBACnC,MAAM,KAAK,GAAW,eAAe,CAAC,OAAO,CAAC,CAAC;gBAC/C,eAAM,CAAC,KAAK,CAAC,8CAA8C,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,OAAO,eAAe,KAAK,IAAI,CAAC,CAAC;gBACrH,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;QACL,CAAC;IACL,CAAC;IACD,MAAM,OAAO,IAAI,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,KAAK,CAAC,EAAU;IACrB,OAAO,IAAI,OAAO,CAAO,CAAC,OAAmB,EAAQ,EAAE;QACnD,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/import/events/activity.d.ts

@@ -0,0 +1,23 @@
+/**
+ * IronBee CLI — Import activity_start / activity_end derivation.
+ *
+ * Behavior:
+ *   - one activity_start + one activity_end per turn (host_inject continuations
+ *     are filtered upstream — by the analytics-runner caller)
+ *   - source: "user_prompt" (we cannot recover the original `pre_tool_use`
+ *     fallback signal from transcript alone)
+ *   - duration_ms on end = end_time - start_time
+ *   - activity_id matches the analytics turn_id (parent foreign key)
+ */
+import { ActivityStartAction, ActivityEndAction } from "../../hooks/core/actions";
+export interface TurnBoundary {
+    /** 1-based positional turn index from the analytics projection. */
+    turnIndex: number;
+    /** ISO-8601 string from the transcript. */
+    startTime: string;
+    /** ISO-8601 string. Falls back to startTime when transcript truncates mid-turn. */
+    endTime: string;
+}
+export declare function buildActivityStart(sessionId: string, projectName: string, boundary: TurnBoundary): ActivityStartAction;
+export declare function buildActivityEnd(sessionId: string, projectName: string, boundary: TurnBoundary): ActivityEndAction;
+//# sourceMappingURL=activity.d.ts.map

package/dist/import/events/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../src/import/events/activity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlF,MAAM,WAAW,YAAY;IACzB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,YAAY,GACvB,mBAAmB,CAWrB;AAED,wBAAgB,gBAAgB,CAC5B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,YAAY,GACvB,iBAAiB,CAenB"}

package/dist/import/events/activity.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * IronBee CLI — Import activity_start / activity_end derivation.
+ *
+ * Behavior:
+ *   - one activity_start + one activity_end per turn (host_inject continuations
+ *     are filtered upstream — by the analytics-runner caller)
+ *   - source: "user_prompt" (we cannot recover the original `pre_tool_use`
+ *     fallback signal from transcript alone)
+ *   - duration_ms on end = end_time - start_time
+ *   - activity_id matches the analytics turn_id (parent foreign key)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildActivityStart = buildActivityStart;
+exports.buildActivityEnd = buildActivityEnd;
+const ids_1 = require("../ids");
+function buildActivityStart(sessionId, projectName, boundary) {
+    const activityId = (0, ids_1.deriveActivityId)(sessionId, boundary.turnIndex, boundary.startTime);
+    return {
+        id: (0, ids_1.deriveActivityStartEventId)(sessionId, boundary.turnIndex),
+        type: "activity_start",
+        timestamp: Date.parse(boundary.startTime),
+        session_id: sessionId,
+        project_name: projectName,
+        activity_id: activityId,
+        source: "user_prompt",
+    };
+}
+function buildActivityEnd(sessionId, projectName, boundary) {
+    const activityId = (0, ids_1.deriveActivityId)(sessionId, boundary.turnIndex, boundary.startTime);
+    const startMs = Date.parse(boundary.startTime);
+    const endMs = Date.parse(boundary.endTime);
+    const durationMs = Number.isFinite(endMs) && Number.isFinite(startMs) ? endMs - startMs : 0;
+    return {
+        id: (0, ids_1.deriveActivityEndEventId)(sessionId, boundary.turnIndex),
+        type: "activity_end",
+        timestamp: Number.isFinite(endMs) ? endMs : startMs,
+        session_id: sessionId,
+        project_name: projectName,
+        activity_id: activityId,
+        duration: durationMs,
+        reason: "import",
+    };
+}
+//# sourceMappingURL=activity.js.map

package/dist/import/events/activity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.js","sourceRoot":"","sources":["../../../src/import/events/activity.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAcH,gDAeC;AAED,4CAmBC;AA/CD,gCAAgG;AAWhG,SAAgB,kBAAkB,CAC9B,SAAiB,EACjB,WAAmB,EACnB,QAAsB;IAEtB,MAAM,UAAU,GAAW,IAAA,sBAAgB,EAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/F,OAAO;QACH,EAAE,EAAE,IAAA,gCAA0B,EAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC;QAC7D,IAAI,EAAE,gBAAgB;QACtB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC;QACzC,UAAU,EAAE,SAAS;QACrB,YAAY,EAAE,WAAW;QACzB,WAAW,EAAE,UAAU;QACvB,MAAM,EAAE,aAAa;KACxB,CAAC;AACN,CAAC;AAED,SAAgB,gBAAgB,CAC5B,SAAiB,EACjB,WAAmB,EACnB,QAAsB;IAEtB,MAAM,UAAU,GAAW,IAAA,sBAAgB,EAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/F,MAAM,OAAO,GAAW,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACvD,MAAM,KAAK,GAAW,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnD,MAAM,UAAU,GAAW,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACpG,OAAO;QACH,EAAE,EAAE,IAAA,8BAAwB,EAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC;QAC3D,IAAI,EAAE,cAAc;QACpB,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO;QACnD,UAAU,EAAE,SAAS;QACrB,YAAY,EAAE,WAAW;QACzB,WAAW,EAAE,UAAU;QACvB,QAAQ,EAAE,UAAU;QACpB,MAAM,EAAE,QAAQ;KACnB,CAAC;AACN,CAAC"}

package/dist/import/events/session.d.ts

@@ -0,0 +1,24 @@
+/**
+ * IronBee CLI — Import session_start / session_end derivation.
+ *
+ * Behavior:
+ *   - timestamp from first/last transcript line
+ *   - id from sha256("session_*:" + session_id)
+ *   - one of each per transcript
+ */
+import { SessionStartAction, SessionEndAction } from "../../hooks/core/actions";
+import { ImportTarget } from "../types";
+/**
+ * Build a `session_start` event from import metadata. `client` is the
+ * upstream agent that produced the transcript ("claude", "cursor", …) —
+ * matches live mode where session-start hooks set the same field. Caller
+ * is the per-client runner (`claude/runner.ts`, `cursor/runner.ts`), so
+ * this stays generic.
+ */
+export declare function buildSessionStart(target: ImportTarget, client: string): SessionStartAction;
+/**
+ * Build a `session_end` event. `endTimestampMs` and `endReason` come from
+ * the transcript tail (last-line timestamp and summary line if present).
+ */
+export declare function buildSessionEnd(target: ImportTarget, endTimestampMs: number, endReason: string): SessionEndAction;
+//# sourceMappingURL=session.d.ts.map

package/dist/import/events/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/import/events/session.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAU1F;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE,YAAY,EACpB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAClB,gBAAgB,CAUlB"}

package/dist/import/events/session.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * IronBee CLI — Import session_start / session_end derivation.
+ *
+ * Behavior:
+ *   - timestamp from first/last transcript line
+ *   - id from sha256("session_*:" + session_id)
+ *   - one of each per transcript
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionStart = buildSessionStart;
+exports.buildSessionEnd = buildSessionEnd;
+const ids_1 = require("../ids");
+/**
+ * Build a `session_start` event from import metadata. `client` is the
+ * upstream agent that produced the transcript ("claude", "cursor", …) —
+ * matches live mode where session-start hooks set the same field. Caller
+ * is the per-client runner (`claude/runner.ts`, `cursor/runner.ts`), so
+ * this stays generic.
+ */
+function buildSessionStart(target, client) {
+    return {
+        id: (0, ids_1.deriveSessionStartEventId)(target.sessionId),
+        type: "session_start",
+        timestamp: target.sessionStartMs,
+        session_id: target.sessionId,
+        project_name: target.projectName,
+        client,
+        source: "import",
+    };
+}
+/**
+ * Build a `session_end` event. `endTimestampMs` and `endReason` come from
+ * the transcript tail (last-line timestamp and summary line if present).
+ */
+function buildSessionEnd(target, endTimestampMs, endReason) {
+    return {
+        id: (0, ids_1.deriveSessionEndEventId)(target.sessionId),
+        type: "session_end",
+        timestamp: endTimestampMs,
+        session_id: target.sessionId,
+        project_name: target.projectName,
+        reason: endReason,
+        duration: endTimestampMs - target.sessionStartMs,
+    };
+}
+//# sourceMappingURL=session.js.map

package/dist/import/events/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../../src/import/events/session.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAaH,8CAUC;AAMD,0CAcC;AAvCD,gCAA4E;AAE5E;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,MAAoB,EAAE,MAAc;IAClE,OAAO;QACH,EAAE,EAAE,IAAA,+BAAyB,EAAC,MAAM,CAAC,SAAS,CAAC;QAC/C,IAAI,EAAE,eAAe;QACrB,SAAS,EAAE,MAAM,CAAC,cAAc;QAChC,UAAU,EAAE,MAAM,CAAC,SAAS;QAC5B,YAAY,EAAE,MAAM,CAAC,WAAW;QAChC,MAAM;QACN,MAAM,EAAE,QAAQ;KACnB,CAAC;AACN,CAAC;AAED;;;GAGG;AACH,SAAgB,eAAe,CAC3B,MAAoB,EACpB,cAAsB,EACtB,SAAiB;IAEjB,OAAO;QACH,EAAE,EAAE,IAAA,6BAAuB,EAAC,MAAM,CAAC,SAAS,CAAC;QAC7C,IAAI,EAAE,aAAa;QACnB,SAAS,EAAE,cAAc;QACzB,UAAU,EAAE,MAAM,CAAC,SAAS;QAC5B,YAAY,EAAE,MAAM,CAAC,WAAW;QAChC,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,cAAc,GAAG,MAAM,CAAC,cAAc;KACnD,CAAC;AACN,CAAC"}

package/dist/import/filter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * IronBee CLI — Import Module Time-Range Filter
+ *
+ * Two-pass filter:
+ *   1. mtime — drop transcripts whose `mtimeMs` falls outside [from, to].
+ *      Already filtered at discovery time (statSync), so no extra I/O here.
+ *   2. session-start timestamp — drop transcripts whose first-line
+ *      `timestamp` is outside the window. Already on the target (read at
+ *      discovery time), so this step is also pure logic.
+ *
+ * Also exports `parseSinceDuration` for `--since 30d` / `2w` / `6m` style
+ * inputs, and `parseIsoDate` for `--from` / `--to`.
+ *
+ *
+ */
+import { ImportTarget, ImportTimeRange } from "./types";
+/**
+ * Apply both passes. Targets whose mtime AND first-line timestamp both fall
+ * inside the window survive. Empty range (`null`) → no filter, all pass.
+ *
+ * The mtime check is the **outer** gate (we'd discover sessions whose mtime
+ * is in-range but whose start is out-of-range — those still pass mtime, fail
+ * start-timestamp). The start-timestamp check is the **inner** gate that
+ * makes `--from / --to` strict.
+ */
+export declare function applyTimeRange(targets: ImportTarget[], range: ImportTimeRange | null): ImportTarget[];
+/**
+ * Parse `--since 30d` / `2w` / `6m` / `12h` into ms. Returns `null` when the
+ * input is malformed or zero/negative.
+ *
+ * Suffixes: `h` (hour), `d` (day), `w` (7-day week), `m` (30-day month).
+ */
+export declare function parseSinceDuration(input: string): number | null;
+/**
+ * Parse an ISO date string (`2025-04-15` or `2025-04-15T12:00:00Z`).
+ * Returns `null` when unparseable. Date-only inputs resolve to local
+ * midnight (matches the analytics `messages_by_date` convention).
+ */
+export declare function parseIsoDate(input: string): number | null;
+/** Build an `ImportTimeRange` from `--since` / `--from / --to` flags. */
+export declare function buildTimeRange(opts: {
+    sinceMs?: number;
+    fromMs?: number;
+    toMs?: number;
+    nowMs: number;
+}): ImportTimeRange | null;
+//# sourceMappingURL=filter.d.ts.map

package/dist/import/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/import/filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,YAAY,EAAE,CAarG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGzD;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB,GAAG,eAAe,GAAG,IAAI,CAQzB"}

package/dist/import/filter.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Time-Range Filter
+ *
+ * Two-pass filter:
+ *   1. mtime — drop transcripts whose `mtimeMs` falls outside [from, to].
+ *      Already filtered at discovery time (statSync), so no extra I/O here.
+ *   2. session-start timestamp — drop transcripts whose first-line
+ *      `timestamp` is outside the window. Already on the target (read at
+ *      discovery time), so this step is also pure logic.
+ *
+ * Also exports `parseSinceDuration` for `--since 30d` / `2w` / `6m` style
+ * inputs, and `parseIsoDate` for `--from` / `--to`.
+ *
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTimeRange = applyTimeRange;
+exports.parseSinceDuration = parseSinceDuration;
+exports.parseIsoDate = parseIsoDate;
+exports.buildTimeRange = buildTimeRange;
+/**
+ * Apply both passes. Targets whose mtime AND first-line timestamp both fall
+ * inside the window survive. Empty range (`null`) → no filter, all pass.
+ *
+ * The mtime check is the **outer** gate (we'd discover sessions whose mtime
+ * is in-range but whose start is out-of-range — those still pass mtime, fail
+ * start-timestamp). The start-timestamp check is the **inner** gate that
+ * makes `--from / --to` strict.
+ */
+function applyTimeRange(targets, range) {
+    if (range === null) {
+        return targets;
+    }
+    return targets.filter((t) => {
+        if (t.mtimeMs < range.fromMs || t.mtimeMs > range.toMs) {
+            return false;
+        }
+        if (t.sessionStartMs < range.fromMs || t.sessionStartMs > range.toMs) {
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Parse `--since 30d` / `2w` / `6m` / `12h` into ms. Returns `null` when the
+ * input is malformed or zero/negative.
+ *
+ * Suffixes: `h` (hour), `d` (day), `w` (7-day week), `m` (30-day month).
+ */
+function parseSinceDuration(input) {
+    const m = input.match(/^(\d+)([hdwm])$/);
+    if (m === null) {
+        return null;
+    }
+    const value = parseInt(m[1], 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    const unit = m[2];
+    const HOUR_MS = 60 * 60 * 1000;
+    const DAY_MS = 24 * HOUR_MS;
+    switch (unit) {
+        case "h": return value * HOUR_MS;
+        case "d": return value * DAY_MS;
+        case "w": return value * 7 * DAY_MS;
+        case "m": return value * 30 * DAY_MS;
+        default: return null;
+    }
+}
+/**
+ * Parse an ISO date string (`2025-04-15` or `2025-04-15T12:00:00Z`).
+ * Returns `null` when unparseable. Date-only inputs resolve to local
+ * midnight (matches the analytics `messages_by_date` convention).
+ */
+function parseIsoDate(input) {
+    const ts = Date.parse(input);
+    return Number.isFinite(ts) ? ts : null;
+}
+/** Build an `ImportTimeRange` from `--since` / `--from / --to` flags. */
+function buildTimeRange(opts) {
+    if (opts.sinceMs !== undefined) {
+        return { fromMs: opts.nowMs - opts.sinceMs, toMs: opts.nowMs };
+    }
+    if (opts.fromMs !== undefined) {
+        return { fromMs: opts.fromMs, toMs: opts.toMs ?? opts.nowMs };
+    }
+    return null;
+}
+//# sourceMappingURL=filter.js.map

package/dist/import/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../src/import/filter.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAaH,wCAaC;AAQD,gDAmBC;AAOD,oCAGC;AAGD,wCAaC;AA3ED;;;;;;;;GAQG;AACH,SAAgB,cAAc,CAAC,OAAuB,EAAE,KAA6B;IACjF,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACjB,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAe,EAAW,EAAE;QAC/C,IAAI,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YACrD,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,CAAC,cAAc,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,cAAc,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YACnE,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,KAAa;IAC5C,MAAM,CAAC,GAA4B,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAClE,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,KAAK,GAAW,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,IAAI,GAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,OAAO,GAAW,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IACvC,MAAM,MAAM,GAAW,EAAE,GAAG,OAAO,CAAC;IACpC,QAAQ,IAAI,EAAE,CAAC;QACX,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,OAAO,CAAC;QACjC,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,MAAM,CAAC;QAChC,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC;QACpC,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,EAAE,GAAG,MAAM,CAAC;QACrC,OAAO,CAAC,CAAC,OAAO,IAAI,CAAC;IACzB,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,KAAa;IACtC,MAAM,EAAE,GAAW,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACrC,OAAO,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC3C,CAAC;AAED,yEAAyE;AACzE,SAAgB,cAAc,CAAC,IAK9B;IACG,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IACnE,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;IAClE,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/dist/import/ids.d.ts

@@ -0,0 +1,56 @@
+/**
+ * IronBee CLI — Import Module Deterministic UUID Derivers
+ *
+ * Every event emitted by `ironbee import` carries a UUID-shaped `id` derived
+ * deterministically from the transcript content (session_id + per-event
+ * positional key). Re-running import on the same transcript produces the
+ * same ids, so collector-side dedup on `(session_id, id)` collapses
+ * duplicates without coordination.
+ *
+ * Analytics events have their own deriver in `src/analytics/projection.ts`
+ * (`deriveSessionAnalyticsEventId`, `deriveTurnEventId`, `deriveStepEventId`).
+ * This module covers the non-analytics import-emitted events: session,
+ * activity, tool_call, file_change.
+ *
+ * All formulas: `formatHexAsUuid(sha256("<event_type>:" + session_id + ":"
+ * + <positional_key>))` — positional key is `turn_index` for activity ids
+ * and `tool_use.id` for tool_call / file_change. Same `(transcript content,
+ * session_id)` always produces the same UUID.
+ */
+export declare function deriveSessionStartEventId(sessionId: string): string;
+export declare function deriveSessionEndEventId(sessionId: string): string;
+/**
+ * Activity (turn) ids. `turnIndex` is the analytics-side `turn_index` (1-based,
+ * positional in the transcript). Activity is one-per-user-turn: host_inject
+ * continuation turns are filtered out before we ever derive an id, so there
+ * are no gaps from the import emitter's perspective.
+ */
+export declare function deriveActivityStartEventId(sessionId: string, turnIndex: number): string;
+export declare function deriveActivityEndEventId(sessionId: string, turnIndex: number): string;
+/**
+/**
+ * Activity-id (the `activity_id` foreign key carried by child events).
+ *
+ * Format: UUID-shaped (8-4-4-4-12) — matches what live mode emits (live
+ * uses `randomUUID()` at the SessionStart hook, baked into `state.json`,
+ * then read by every PreToolUse). Backends that store `activity_id` as a
+ * UUID column accept both live and import values uniformly.
+ *
+ * Determinism: same `(session_id, turn_index, start_time)` tuple always
+ * produces the same UUID, so re-imports collide cleanly. Independent of
+ * `session_turn_analytics.turn_id` (which keeps its 16-char hex form per
+ * analytics spec) — they're separate identifiers for related-but-distinct
+ * concepts (hook-runtime activity vs. analytics-projection turn).
+ */
+export declare function deriveActivityId(sessionId: string, turnIndex: number, startTime: string): string;
+/**
+ * Default tool_call event id when `_metadata.toolCallId` is absent (transcript
+ * predates the `_metadata.toolCallId` convention). Falls back to a
+ * deterministic derivation from the host's `tool_use.id`. For transcripts
+ * that DO carry `_metadata.toolCallId`, the import emitter uses that
+ * UUID verbatim instead — collapses cleanly with the live MCP-shipped
+ * event id on the collector.
+ */
+export declare function deriveToolCallEventIdFromToolUseId(sessionId: string, toolUseId: string): string;
+export declare function deriveFileChangeEventId(sessionId: string, toolUseId: string): string;
+//# sourceMappingURL=ids.d.ts.map

package/dist/import/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/import/ids.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAErF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGhG;AAED;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/F;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpF"}

package/dist/import/ids.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Deterministic UUID Derivers
+ *
+ * Every event emitted by `ironbee import` carries a UUID-shaped `id` derived
+ * deterministically from the transcript content (session_id + per-event
+ * positional key). Re-running import on the same transcript produces the
+ * same ids, so collector-side dedup on `(session_id, id)` collapses
+ * duplicates without coordination.
+ *
+ * Analytics events have their own deriver in `src/analytics/projection.ts`
+ * (`deriveSessionAnalyticsEventId`, `deriveTurnEventId`, `deriveStepEventId`).
+ * This module covers the non-analytics import-emitted events: session,
+ * activity, tool_call, file_change.
+ *
+ * All formulas: `formatHexAsUuid(sha256("<event_type>:" + session_id + ":"
+ * + <positional_key>))` — positional key is `turn_index` for activity ids
+ * and `tool_use.id` for tool_call / file_change. Same `(transcript content,
+ * session_id)` always produces the same UUID.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSessionStartEventId = deriveSessionStartEventId;
+exports.deriveSessionEndEventId = deriveSessionEndEventId;
+exports.deriveActivityStartEventId = deriveActivityStartEventId;
+exports.deriveActivityEndEventId = deriveActivityEndEventId;
+exports.deriveActivityId = deriveActivityId;
+exports.deriveToolCallEventIdFromToolUseId = deriveToolCallEventIdFromToolUseId;
+exports.deriveFileChangeEventId = deriveFileChangeEventId;
+const crypto_1 = require("crypto");
+const projection_1 = require("../analytics/projection");
+/** SHA-256 the input and format the first 32 hex chars as a UUID. */
+function sha256Uuid(input) {
+    const hex32 = (0, crypto_1.createHash)("sha256").update(input).digest("hex").slice(0, 32);
+    return (0, projection_1.formatHexAsUuid)(hex32);
+}
+function deriveSessionStartEventId(sessionId) {
+    return sha256Uuid(`session_start:${sessionId}`);
+}
+function deriveSessionEndEventId(sessionId) {
+    return sha256Uuid(`session_end:${sessionId}`);
+}
+/**
+ * Activity (turn) ids. `turnIndex` is the analytics-side `turn_index` (1-based,
+ * positional in the transcript). Activity is one-per-user-turn: host_inject
+ * continuation turns are filtered out before we ever derive an id, so there
+ * are no gaps from the import emitter's perspective.
+ */
+function deriveActivityStartEventId(sessionId, turnIndex) {
+    return sha256Uuid(`activity_start:${sessionId}:${turnIndex}`);
+}
+function deriveActivityEndEventId(sessionId, turnIndex) {
+    return sha256Uuid(`activity_end:${sessionId}:${turnIndex}`);
+}
+/**
+/**
+ * Activity-id (the `activity_id` foreign key carried by child events).
+ *
+ * Format: UUID-shaped (8-4-4-4-12) — matches what live mode emits (live
+ * uses `randomUUID()` at the SessionStart hook, baked into `state.json`,
+ * then read by every PreToolUse). Backends that store `activity_id` as a
+ * UUID column accept both live and import values uniformly.
+ *
+ * Determinism: same `(session_id, turn_index, start_time)` tuple always
+ * produces the same UUID, so re-imports collide cleanly. Independent of
+ * `session_turn_analytics.turn_id` (which keeps its 16-char hex form per
+ * analytics spec) — they're separate identifiers for related-but-distinct
+ * concepts (hook-runtime activity vs. analytics-projection turn).
+ */
+function deriveActivityId(sessionId, turnIndex, startTime) {
+    const hex32 = (0, crypto_1.createHash)("sha256").update(`${sessionId}|${turnIndex}|${startTime}`).digest("hex").slice(0, 32);
+    return (0, projection_1.formatHexAsUuid)(hex32);
+}
+/**
+ * Default tool_call event id when `_metadata.toolCallId` is absent (transcript
+ * predates the `_metadata.toolCallId` convention). Falls back to a
+ * deterministic derivation from the host's `tool_use.id`. For transcripts
+ * that DO carry `_metadata.toolCallId`, the import emitter uses that
+ * UUID verbatim instead — collapses cleanly with the live MCP-shipped
+ * event id on the collector.
+ */
+function deriveToolCallEventIdFromToolUseId(sessionId, toolUseId) {
+    return sha256Uuid(`tool_call:${sessionId}:${toolUseId}`);
+}
+function deriveFileChangeEventId(sessionId, toolUseId) {
+    return sha256Uuid(`file_change:${sessionId}:${toolUseId}`);
+}
+//# sourceMappingURL=ids.js.map

package/dist/import/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../src/import/ids.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;AAWH,8DAEC;AAED,0DAEC;AAQD,gEAEC;AAED,4DAEC;AAiBD,4CAGC;AAUD,gFAEC;AAED,0DAEC;AAjED,mCAAoC;AACpC,wDAA0D;AAE1D,qEAAqE;AACrE,SAAS,UAAU,CAAC,KAAa;IAC7B,MAAM,KAAK,GAAW,IAAA,mBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACpF,OAAO,IAAA,4BAAe,EAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,SAAgB,yBAAyB,CAAC,SAAiB;IACvD,OAAO,UAAU,CAAC,iBAAiB,SAAS,EAAE,CAAC,CAAC;AACpD,CAAC;AAED,SAAgB,uBAAuB,CAAC,SAAiB;IACrD,OAAO,UAAU,CAAC,eAAe,SAAS,EAAE,CAAC,CAAC;AAClD,CAAC;AAED;;;;;GAKG;AACH,SAAgB,0BAA0B,CAAC,SAAiB,EAAE,SAAiB;IAC3E,OAAO,UAAU,CAAC,kBAAkB,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAClE,CAAC;AAED,SAAgB,wBAAwB,CAAC,SAAiB,EAAE,SAAiB;IACzE,OAAO,UAAU,CAAC,gBAAgB,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,gBAAgB,CAAC,SAAiB,EAAE,SAAiB,EAAE,SAAiB;IACpF,MAAM,KAAK,GAAW,IAAA,mBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,IAAI,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACvH,OAAO,IAAA,4BAAe,EAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kCAAkC,CAAC,SAAiB,EAAE,SAAiB;IACnF,OAAO,UAAU,CAAC,aAAa,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED,SAAgB,uBAAuB,CAAC,SAAiB,EAAE,SAAiB;IACxE,OAAO,UAAU,CAAC,eAAe,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAC/D,CAAC"}

package/dist/import/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * IronBee CLI — Import Module Public Barrel
+ *
+ * Exposes ONLY the client-agnostic API. Client-specific modules
+ * (`claude/**`, future `cursor/**`) are NOT re-exported here —
+ * `commands/import.ts` and any other consumer must go through the
+ * generic dispatcher in `pipeline.ts` so adding a new client never
+ * forces a CLI change.
+ *
+ * Public surface:
+ *   - findTranscripts(scope)       — discovery (dispatched per client)
+ *   - estimateImport(opts)         — dry-run estimator (dispatched per client)
+ *   - importSession(opts)          — per-session driver (dispatched per client)
+ *   - applyTimeRange / parseSinceDuration / parseIsoDate / buildTimeRange — generic
+ *   - shouldSkip                   — generic skip rule
+ *   - writeImportMarker / readImportMarker — generic marker file R/W
+ *   - postEvents                   — generic collector POST helper
+ *   - ProgressReporter             — generic progress UI
+ *   - All `Import*` types
+ */
+export { findTranscripts, estimateImport, importSession, ImportSessionOpts, EstimateOpts } from "./pipeline";
+export { runConcurrentPool, ConcurrentPoolOpts } from "./concurrent-pool";
+export { applyTimeRange, parseSinceDuration, parseIsoDate, buildTimeRange } from "./filter";
+export { shouldSkip } from "./skip";
+export { writeImportMarker, readImportMarker, MARKER_SCHEMA_VERSION, markerPath } from "./marker";
+export { postEvents, EmitterOpts } from "./emitter";
+export { ProgressReporter } from "./progress";
+export { ImportEventCounts, ImportMarker, ImportOptions, ImportProjectSummary, ImportResult, ImportScope, ImportSummary, ImportTarget, ImportTimeRange, DerivedEvent, emptyEventCounts, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/import/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/import/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG7G,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,OAAO,EACH,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,WAAW,EACX,aAAa,EACb,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,gBAAgB,GACnB,MAAM,SAAS,CAAC"}