@steel-dev/atlas 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,80 @@
+import type { PricingTable } from "./budget.js";
+import type { ResearchTool } from "./custom-tools.js";
+import type { ModelRole, ResolvedModel } from "./model.js";
+import type { FetchProvider } from "./providers/fetch.js";
+import type { SearchProvider } from "./providers/search.js";
+import type { RunStore } from "./providers/store.js";
+import type { Researcher } from "./researcher.js";
+import type { SafetyPolicy } from "./safety.js";
+export type Effort = "fast" | "balanced" | "deep" | "max";
+export type TraceMode = "off" | "spans" | "full";
+export interface EffortEnvelope {
+    budgetUSD: number;
+    maxSources: number;
+    maxTokens: number;
+    maxTurns: number;
+    maxReportTokens: number;
+    maxDurationMs: number;
+}
+export declare const EFFORT_ENVELOPES: Record<Effort, EffortEnvelope>;
+export interface Budget {
+    maxUSD?: number;
+    maxTokens?: number;
+    maxDurationMs?: number;
+    maxSources?: number;
+}
+export interface SourceFilter {
+    includeDomains?: string[];
+    excludeDomains?: string[];
+}
+export interface ConcurrencyConfig {
+    models?: number;
+    io?: number;
+}
+export type SearchConfig = SearchProvider | SearchProvider[] | Record<string, SearchProvider | SearchProvider[]>;
+export interface AtlasConfig {
+    model: ResolvedModel;
+    models?: {
+        research?: ResolvedModel;
+        write?: ResolvedModel;
+    };
+    search?: SearchConfig;
+    fetch?: FetchProvider | FetchProvider[];
+    effort?: Effort;
+    budget?: Budget;
+    store?: RunStore;
+    pricing?: PricingTable;
+    safety?: SafetyPolicy;
+    instructions?: string;
+    tools?: Record<string, ResearchTool>;
+    researchers?: Record<string, Researcher>;
+    concurrency?: ConcurrencyConfig;
+    trace?: TraceMode;
+}
+export interface ResearchOptions {
+    effort?: Effort;
+    budget?: Budget;
+    sources?: SourceFilter;
+    signal?: AbortSignal;
+    runId?: string;
+    trace?: TraceMode;
+}
+export interface ResolvedRunConfig {
+    effort: Effort;
+    envelope: EffortEnvelope;
+    budgetUSD: number;
+    maxTokens: number;
+    maxDurationMs?: number | undefined;
+    maxSources: number;
+    models: Record<ModelRole, ResolvedModel>;
+    leadModelId: string;
+    pricing: PricingTable;
+    safety: SafetyPolicy;
+    sourceFilter?: SourceFilter | undefined;
+    instructions?: string | undefined;
+    maxConcurrentModelCalls: number;
+    maxConcurrentIo: number;
+    trace: TraceMode;
+    researchers: Record<string, Researcher>;
+}
+export declare function resolveRunConfig(config: AtlasConfig, options: ResearchOptions): ResolvedRunConfig;

package/dist/config.js

@@ -0,0 +1,109 @@
+import { readEnv } from "./env.js";
+import { AtlasError } from "./errors.js";
+export const EFFORT_ENVELOPES = {
+    fast: {
+        budgetUSD: 0.5,
+        maxSources: 15,
+        maxTokens: 200_000,
+        maxTurns: 30,
+        maxReportTokens: 4_096,
+        maxDurationMs: 600_000,
+    },
+    balanced: {
+        budgetUSD: 2.5,
+        maxSources: 40,
+        maxTokens: 1_000_000,
+        maxTurns: 60,
+        maxReportTokens: 12_288,
+        maxDurationMs: 1_200_000,
+    },
+    deep: {
+        budgetUSD: 10,
+        maxSources: 100,
+        maxTokens: 4_000_000,
+        maxTurns: 100,
+        maxReportTokens: 16_384,
+        maxDurationMs: 2_400_000,
+    },
+    max: {
+        budgetUSD: 40,
+        maxSources: 250,
+        maxTokens: 16_000_000,
+        maxTurns: 150,
+        maxReportTokens: 24_576,
+        maxDurationMs: 3_600_000,
+    },
+};
+for (const envelope of Object.values(EFFORT_ENVELOPES)) {
+    Object.freeze(envelope);
+}
+Object.freeze(EFFORT_ENVELOPES);
+const DEFAULT_MODEL_CONCURRENCY = 4;
+const DEFAULT_IO_CONCURRENCY = 10;
+function resolveConcurrency(configured, fallback, ...keys) {
+    if (configured !== undefined &&
+        Number.isFinite(configured) &&
+        configured >= 1) {
+        return Math.floor(configured);
+    }
+    const raw = readEnv(...keys);
+    if (raw === undefined)
+        return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return fallback;
+    return Math.floor(parsed);
+}
+export function resolveRunConfig(config, options) {
+    if (!config.model || typeof config.model === "string") {
+        throw new AtlasError('Atlas requires a model instance (e.g. anthropic("claude-fable-5")); model id strings are not accepted', "config");
+    }
+    const effort = options.effort ?? config.effort ?? "balanced";
+    const envelope = EFFORT_ENVELOPES[effort];
+    if (!envelope) {
+        throw new AtlasError(`unknown effort "${effort}" (expected fast | balanced | deep | max)`, "config");
+    }
+    const budget = { ...config.budget, ...options.budget };
+    const budgetUSD = budget.maxUSD ?? envelope.budgetUSD;
+    if (!Number.isFinite(budgetUSD) || budgetUSD <= 0) {
+        throw new AtlasError(`budget.maxUSD must be > 0 (got ${budgetUSD})`, "config");
+    }
+    const maxTokens = budget.maxTokens ?? envelope.maxTokens;
+    if (!Number.isFinite(maxTokens) || maxTokens <= 0) {
+        throw new AtlasError(`budget.maxTokens must be > 0 (got ${maxTokens})`, "config");
+    }
+    const maxSources = budget.maxSources ?? envelope.maxSources;
+    if (!Number.isFinite(maxSources) || maxSources <= 0) {
+        throw new AtlasError(`budget.maxSources must be > 0 (got ${maxSources})`, "config");
+    }
+    const maxDurationMs = budget.maxDurationMs ?? envelope.maxDurationMs;
+    if (maxDurationMs !== undefined &&
+        (!Number.isFinite(maxDurationMs) || maxDurationMs <= 0)) {
+        throw new AtlasError(`budget.maxDurationMs must be > 0 (got ${maxDurationMs})`, "config");
+    }
+    const lead = config.model;
+    const models = {
+        lead,
+        research: config.models?.research ?? lead,
+        write: config.models?.write ?? lead,
+    };
+    const leadModelId = lead.modelId ?? "";
+    return {
+        effort,
+        envelope,
+        budgetUSD,
+        maxTokens,
+        maxDurationMs,
+        maxSources,
+        models,
+        leadModelId,
+        pricing: config.pricing ?? {},
+        safety: config.safety ?? {},
+        sourceFilter: options.sources,
+        instructions: config.instructions,
+        maxConcurrentModelCalls: resolveConcurrency(config.concurrency?.models, DEFAULT_MODEL_CONCURRENCY, "ATLAS_MODEL_CONCURRENCY"),
+        maxConcurrentIo: resolveConcurrency(config.concurrency?.io, DEFAULT_IO_CONCURRENCY, "ATLAS_IO_CONCURRENCY"),
+        trace: options.trace ?? config.trace ?? "off",
+        researchers: config.researchers ?? {},
+    };
+}

package/dist/context.d.ts

@@ -0,0 +1,26 @@
+import { type BudgetGrant, type BudgetMeter } from "./budget.js";
+import type { AtlasConfig, ResolvedRunConfig } from "./config.js";
+import type { EventHub } from "./event-hub.js";
+import type { JournalWriter, ReplayCache } from "./providers/store.js";
+import { type RunCtx } from "./state.js";
+export interface AssembleRunArgs {
+    runId: string;
+    question: string;
+    todayISO: string;
+    resolved: ResolvedRunConfig;
+    config: AtlasConfig;
+    journal: JournalWriter;
+    replay?: ReplayCache | undefined;
+    hub: EventHub;
+    hardSignal: AbortSignal;
+    stopSignal: AbortSignal;
+    now: () => number;
+    startedAt: number;
+}
+export interface RunAssembly {
+    rctx: RunCtx;
+    meter: BudgetMeter;
+    synthesisGrant: BudgetGrant;
+}
+export declare function assembleRun(args: AssembleRunArgs): Promise<RunAssembly>;
+export declare function deriveChildCtx(parent: RunCtx, question: string): RunCtx;

package/dist/context.js

@@ -0,0 +1,250 @@
+import { createAdaptiveLimit, createConcurrencyGate, createDynamicConcurrencyGate, } from "./async.js";
+import { createBudgetMeter, DEFAULT_PRICING, } from "./budget.js";
+import { resolveCustomTools } from "./custom-tools.js";
+import { isSmallModelId } from "./defaults.js";
+import { ECONOMY } from "./economy.js";
+import { createModelCallCache, createRunUsage, engineModel, totalFreshTokens, } from "./model.js";
+import { defaultFetchProviders } from "./providers/fetch.js";
+import { combineSearchProviders, defaultSearchProviders, } from "./providers/search.js";
+import { createSafeDispatcher } from "./safe-dispatcher.js";
+import { isRunCodeAvailable } from "./sandbox.js";
+import { createRunCounters, createSourceStore, } from "./state.js";
+import { createTraceRecorder } from "./trace.js";
+import { createTrail } from "./trail.js";
+const TIMEOUT_SYNTHESIS_RESERVE_MS = 120_000;
+const BUDGET_WARNING_FRACTIONS = [0.5, 0.8, 0.95];
+const UNJOURNALED_EVENTS = new Set([
+    "report.delta",
+    "report.reset",
+]);
+export async function assembleRun(args) {
+    const { runId, question, resolved } = args;
+    const meter = createBudgetMeter(resolved.budgetUSD);
+    const usage = createRunUsage();
+    const pricing = { ...DEFAULT_PRICING, ...resolved.pricing };
+    const makeModelLimit = () => createAdaptiveLimit({
+        start: resolved.maxConcurrentModelCalls,
+        min: Math.min(2, resolved.maxConcurrentModelCalls),
+        max: resolved.maxConcurrentModelCalls * 2,
+    });
+    const heavyLimit = makeModelLimit();
+    const smallLimit = makeModelLimit();
+    const ioGate = createConcurrencyGate(resolved.maxConcurrentIo);
+    const modelCache = createModelCallCache();
+    const callOrdinals = new Map();
+    const counters = createRunCounters();
+    const warnedUnknownModels = new Set();
+    const warnedFractions = new Set();
+    const deadlineAt = resolved.maxDurationMs
+        ? args.startedAt + resolved.maxDurationMs
+        : undefined;
+    const recorder = resolved.trace !== "off"
+        ? createTraceRecorder({
+            mode: resolved.trace,
+            now: args.now,
+            startedAt: args.startedAt,
+        })
+        : undefined;
+    recorder?.setSink((kind, _id, data) => args.journal.trace(kind, data));
+    const budgetExhausted = () => meter.exhausted();
+    const tokensExhausted = () => totalFreshTokens(usage) >= resolved.maxTokens;
+    const emit = (event) => {
+        args.hub.emit(event);
+        if (!UNJOURNALED_EVENTS.has(event.type)) {
+            args.journal.event(event.type, event);
+        }
+    };
+    const trackGateWidth = () => {
+        counters.modelGatePeakWidth = Math.max(counters.modelGatePeakWidth, heavyLimit.value() + smallLimit.value());
+    };
+    const emitBudgetWarnings = () => {
+        const fraction = meter.totalSpentUSD() / meter.totalUSD;
+        for (const threshold of BUDGET_WARNING_FRACTIONS) {
+            if (fraction >= threshold && !warnedFractions.has(threshold)) {
+                warnedFractions.add(threshold);
+                emit({
+                    type: "budget.warning",
+                    spentUSD: meter.totalSpentUSD(),
+                    limitUSD: meter.totalUSD,
+                    fraction: threshold,
+                });
+            }
+        }
+    };
+    const makeTier = (limit) => ({
+        gate: createDynamicConcurrencyGate(() => limit.value()),
+        onCost: () => {
+            limit.onSuccess();
+            trackGateWidth();
+            emitBudgetWarnings();
+        },
+        onRateLimit: ({ delayMs }) => {
+            limit.onThrottle();
+            emit({
+                type: "rate.limited",
+                retryAfterSeconds: Math.max(1, Math.round(delayMs / 1000)),
+            });
+        },
+    });
+    const heavyTier = makeTier(heavyLimit);
+    const smallTier = makeTier(smallLimit);
+    const tierForRole = (role) => isSmallModelId(resolved.models[role].modelId ?? "")
+        ? smallTier
+        : heavyTier;
+    const onUnknownModel = (modelId) => {
+        if (warnedUnknownModels.has(modelId))
+            return;
+        warnedUnknownModels.add(modelId);
+        emit({
+            type: "pricing.missing",
+            modelId,
+            detail: `no pricing entry for model "${modelId}"; charging neutral mid-tier default rates — set config.pricing for accurate cost`,
+        });
+    };
+    const bindModelWithTier = (role, grant, tier) => engineModel(resolved.models[role], {
+        role,
+        grant,
+        pricing,
+        gate: tier.gate,
+        usage,
+        journal: args.journal,
+        replay: args.replay,
+        modelCache,
+        callOrdinals,
+        recorder,
+        onCost: tier.onCost,
+        onUnknownModel,
+        onRateLimit: tier.onRateLimit,
+        onCacheHit: () => {
+            counters.modelCacheHits++;
+        },
+        budgetExhausted: () => grant.spentUSD() >= grant.limitUSD,
+    });
+    const bindModel = (role, grant) => bindModelWithTier(role, grant, tierForRole(role));
+    const { search, searchBySource } = resolveSearchConfig(args.config.search, () => defaultSearchProviders(bindModelWithTier("research", meter, tierForRole("research"))));
+    const fetchChain = Array.isArray(args.config.fetch)
+        ? args.config.fetch
+        : args.config.fetch
+            ? [args.config.fetch]
+            : defaultFetchProviders();
+    const safeDispatcher = createSafeDispatcher(resolved.safety);
+    const customTools = await resolveCustomTools(args.config.tools);
+    const runCodeEnabled = await isRunCodeAvailable();
+    const synthesisGrant = meter.grant({
+        fraction: ECONOMY.synthesis.fraction,
+        minUSD: ECONOMY.synthesis.minUSD,
+    }) ?? meter;
+    const rctx = {
+        runId,
+        question,
+        todayISO: args.todayISO,
+        config: resolved,
+        meter,
+        usage,
+        pricing,
+        ledger: null,
+        trail: createTrail(),
+        notes: [],
+        readCounts: new Map(),
+        sources: createSourceStore(),
+        search,
+        searchBySource,
+        oaCandidates: new Map(),
+        surfacedCandidates: new Map(),
+        fetchChain,
+        safeDispatcher,
+        customTools,
+        runCodeEnabled,
+        emit,
+        journal: args.journal,
+        replay: args.replay,
+        recorder,
+        signal: args.hardSignal,
+        stopSignal: args.stopSignal,
+        deadlineAt,
+        now: args.now,
+        modelGate: heavyTier.gate,
+        ioGate,
+        seenDomains: new Set(),
+        counters,
+        agentSequence: { next: 1 },
+        bindModel,
+        rawModel: (role) => resolved.models[role],
+        stopReason: () => {
+            if (args.stopSignal.aborted)
+                return "stop requested";
+            if (deadlineAt !== undefined &&
+                args.now() > deadlineAt - TIMEOUT_SYNTHESIS_RESERVE_MS) {
+                return "timeout approaching";
+            }
+            if (budgetExhausted())
+                return "budget exhausted";
+            if (tokensExhausted())
+                return "token budget reached";
+            return null;
+        },
+    };
+    if (args.replay)
+        primeSourceNumbers(rctx.sources, args.replay);
+    return {
+        rctx,
+        meter,
+        synthesisGrant,
+    };
+}
+function isSearchProvider(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.id === "string" &&
+        typeof value.search === "function");
+}
+function resolveSearchConfig(raw, webFallback) {
+    const flat = (providers) => {
+        const web = combineSearchProviders(providers.length > 0 ? providers : webFallback());
+        return { search: web, searchBySource: new Map([["web", web]]) };
+    };
+    if (raw === undefined)
+        return flat([]);
+    if (isSearchProvider(raw))
+        return flat([raw]);
+    if (Array.isArray(raw))
+        return flat(raw);
+    const searchBySource = new Map();
+    for (const [source, value] of Object.entries(raw)) {
+        const providers = Array.isArray(value) ? value : [value];
+        if (providers.length > 0) {
+            searchBySource.set(source, combineSearchProviders(providers));
+        }
+    }
+    if (!searchBySource.has("web")) {
+        searchBySource.set("web", combineSearchProviders(webFallback()));
+    }
+    return { search: searchBySource.get("web"), searchBySource };
+}
+function primeSourceNumbers(sources, replay) {
+    let max = 0;
+    for (const prefix of ["fetch:", "custom-source:"]) {
+        for (const value of replay.values(prefix)) {
+            const sourceId = value?.sourceId;
+            const match = typeof sourceId === "string" ? /^source_(\d+)$/.exec(sourceId) : null;
+            if (match)
+                max = Math.max(max, Number(match[1]));
+        }
+    }
+    if (max >= sources.nextSourceNumber)
+        sources.nextSourceNumber = max + 1;
+}
+export function deriveChildCtx(parent, question) {
+    return {
+        ...parent,
+        question,
+        ledger: null,
+        trail: createTrail(),
+        notes: [],
+        readCounts: new Map(),
+        sources: createSourceStore(),
+        oaCandidates: new Map(),
+        surfacedCandidates: new Map(),
+        seenDomains: new Set(),
+    };
+}

package/dist/custom-tools.d.ts

@@ -0,0 +1,26 @@
+import { type FlexibleSchema } from "ai";
+export interface ToolContext {
+    addSource(source: {
+        url: string;
+        title?: string;
+        content: string;
+    }): void;
+    fetchText(url: string): Promise<string | null>;
+    readonly signal?: AbortSignal | undefined;
+    log(message: string): void;
+}
+export interface ResearchTool<I = unknown> {
+    description: string;
+    inputSchema: FlexibleSchema<I>;
+    timeoutMs?: number;
+    execute(input: I, ctx: ToolContext): string | Promise<string>;
+}
+export interface ResolvedCustomTool {
+    name: string;
+    description: string;
+    inputJsonSchema: Record<string, unknown>;
+    timeoutMs?: number | undefined;
+    execute(input: unknown, ctx: ToolContext): string | Promise<string>;
+}
+export declare function researchTool<I>(tool: ResearchTool<I>): ResearchTool<I>;
+export declare function resolveCustomTools(tools: Record<string, ResearchTool> | undefined): Promise<Map<string, ResolvedCustomTool>>;

package/dist/custom-tools.js

@@ -0,0 +1,33 @@
+import { asSchema } from "ai";
+import { AtlasError } from "./errors.js";
+import { BUILTIN_TOOL_NAMES, LEDGER_TOOL_NAMES } from "./tools.js";
+const RESERVED_TOOL_NAMES = new Set([
+    ...BUILTIN_TOOL_NAMES,
+    ...LEDGER_TOOL_NAMES,
+]);
+const TOOL_NAME_PATTERN = /^[A-Za-z][\w-]{0,63}$/;
+export function researchTool(tool) {
+    return tool;
+}
+export async function resolveCustomTools(tools) {
+    const resolved = new Map();
+    if (!tools)
+        return resolved;
+    for (const [name, tool] of Object.entries(tools)) {
+        if (RESERVED_TOOL_NAMES.has(name)) {
+            throw new AtlasError(`custom tool "${name}" would shadow the builtin ${name} tool; pick another name`, "config");
+        }
+        if (!TOOL_NAME_PATTERN.test(name)) {
+            throw new AtlasError(`custom tool name "${name}" is invalid: use 1-64 letters, digits, _ or -, starting with a letter`, "config");
+        }
+        const jsonSchemaObject = await Promise.resolve(asSchema(tool.inputSchema).jsonSchema);
+        resolved.set(name, {
+            name,
+            description: tool.description,
+            inputJsonSchema: jsonSchemaObject,
+            timeoutMs: tool.timeoutMs,
+            execute: tool.execute,
+        });
+    }
+    return resolved;
+}

package/dist/defaults.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedModel } from "./model.js";
+export declare const DEFAULT_ANTHROPIC_MODEL = "claude-opus-4-8";
+export declare const DEFAULT_OPENAI_MODEL = "gpt-5.5";
+export declare const DEFAULT_ZAI_MODEL = "glm-5.2";
+export declare const DEFAULT_ZAI_BASE_URL = "https://api.z.ai/api/paas/v4";
+export declare function isSmallModelId(modelId: string): boolean;
+export declare function isZaiModelId(modelId: string): boolean;
+export declare function contextWindowTokens(model: ResolvedModel): number;
+export declare function extractionCharsFor(model: ResolvedModel): number;
+export declare function leadContextTokensFor(model: ResolvedModel): number;

package/dist/defaults.js

@@ -0,0 +1,37 @@
+export const DEFAULT_ANTHROPIC_MODEL = "claude-opus-4-8";
+export const DEFAULT_OPENAI_MODEL = "gpt-5.5";
+export const DEFAULT_ZAI_MODEL = "glm-5.2";
+export const DEFAULT_ZAI_BASE_URL = "https://api.z.ai/api/paas/v4";
+const SMALL_MODEL_ID_PATTERN = /haiku|mini|nano|flash|lite/i;
+const ZAI_MODEL_ID_PATTERN = /^glm-/i;
+const ZAI_SMALL_MODEL_ID_PATTERN = /^glm-4\.5-air$/i;
+export function isSmallModelId(modelId) {
+    return (SMALL_MODEL_ID_PATTERN.test(modelId) ||
+        ZAI_SMALL_MODEL_ID_PATTERN.test(modelId));
+}
+export function isZaiModelId(modelId) {
+    return ZAI_MODEL_ID_PATTERN.test(modelId);
+}
+const CONTEXT_WINDOW_BY_PATTERN = [
+    [/haiku|mini|nano|flash|lite/i, 200_000],
+    [/opus|sonnet|fable|mythos/i, 1_000_000],
+];
+const DEFAULT_CONTEXT_WINDOW_TOKENS = 200_000;
+const CHARS_PER_TOKEN = 4;
+const EXTRACTION_CONTEXT_FRACTION = 0.3;
+const LEAD_CONTEXT_TARGET_TOKENS = 80_000;
+const LEAD_CONTEXT_MAX_FRACTION = 0.4;
+export function contextWindowTokens(model) {
+    const modelId = model.modelId ?? "";
+    for (const [pattern, window] of CONTEXT_WINDOW_BY_PATTERN) {
+        if (pattern.test(modelId))
+            return window;
+    }
+    return DEFAULT_CONTEXT_WINDOW_TOKENS;
+}
+export function extractionCharsFor(model) {
+    return Math.round(contextWindowTokens(model) * EXTRACTION_CONTEXT_FRACTION * CHARS_PER_TOKEN);
+}
+export function leadContextTokensFor(model) {
+    return Math.min(LEAD_CONTEXT_TARGET_TOKENS, Math.round(contextWindowTokens(model) * LEAD_CONTEXT_MAX_FRACTION));
+}

package/dist/economy.d.ts

@@ -0,0 +1,12 @@
+export declare const ECONOMY: {
+    readonly grantFloorUSD: 0.02;
+    readonly defaultGrantFraction: 0.15;
+    readonly synthesis: {
+        readonly fraction: 0.15;
+        readonly minUSD: 0.05;
+    };
+    readonly callReserve: {
+        readonly promptCharsPerToken: 4;
+        readonly assumedOutputTokens: 2000;
+    };
+};

package/dist/economy.js

@@ -0,0 +1,6 @@
+export const ECONOMY = {
+    grantFloorUSD: 0.02,
+    defaultGrantFraction: 0.15,
+    synthesis: { fraction: 0.15, minUSD: 0.05 },
+    callReserve: { promptCharsPerToken: 4, assumedOutputTokens: 2_000 },
+};

package/dist/env.d.ts

@@ -0,0 +1 @@
+export declare function readEnv(...keys: string[]): string | undefined;

package/dist/env.js

@@ -0,0 +1,8 @@
+export function readEnv(...keys) {
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value?.trim())
+            return value.trim();
+    }
+    return undefined;
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare function errorMessage(err: unknown): string;
+export type AtlasErrorCode = "config" | "budget" | "resume" | "aborted" | "paused" | "timeout";
+export declare class AtlasError extends Error {
+    readonly code: AtlasErrorCode;
+    constructor(message: string, code: AtlasErrorCode);
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+export function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export class AtlasError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "AtlasError";
+    }
+}

package/dist/event-hub.d.ts

@@ -0,0 +1,11 @@
+import type { ResearchEvent } from "./events.js";
+export declare class EventHub {
+    private readonly subscribers;
+    private readonly history;
+    private closed;
+    private failure;
+    emit(event: ResearchEvent): void;
+    close(): void;
+    fail(error: unknown): void;
+    iterable(): AsyncIterable<ResearchEvent>;
+}