@vincemakes/kiso-runtime 0.1.38 → 0.2.0

package/dist/trace/guard.js

@@ -0,0 +1,208 @@
+/**
+ * E1 (1.2.0) — slice 3, the request tracer (the guard).
+ *
+ * One TraceRecord per adapter call, settled when the stream ends. The
+ * guard lives AT the adapter boundary (run.ts wires
+ * truncationGuard(traceGuard(tracer, adapter))): the kernel, the log,
+ * and the model-visible byte stream are untouched (I6 — pinned by
+ * trace-bytes.test.ts). retryAttempt counts prior calls in this run
+ * with an identical contextHash — the loop re-streams the SAME messages
+ * array on retry (loop.ts), so an identical hash is exactly "same
+ * request, retried" (§1.4).
+ *
+ * Soft-fail: any failure in trace assembly (never expected — hashes and
+ * the manifest cannot throw today) marks the request ABSENT rather than
+ * breaking the stream; the writer's own degradation covers I/O.
+ *
+ * Usage is provider-raw, never normalized (E2's job): openai-compat
+ * reports input TOTAL (fresh = input − cacheRead); anthropic's
+ * input_tokens is ALREADY fresh-only (the trace records it as-is).
+ * A request that settles with NO usage data records the quartet as
+ * zeros with cacheWrite null — "0 = unknown", documented at record.ts;
+ * the honest nullable quartet is a schema bump, deferred.
+ */
+import { randomUUID } from "node:crypto";
+import { buildContextManifest, segmentHashes } from "./manifest.js";
+import { cacheableHashes } from "./analyze.js";
+import { hashContext, hashSystemPrompt, hashToolSpecs, stablePrefixFingerprint } from "./hash.js";
+import { PRICING_TABLE_V1, canonicalizeUsage } from "../usage/canonical.js";
+import { TRACE_SCHEMA_VERSION } from "./record.js";
+import { TraceWriter } from "./writer.js";
+export class RequestTracer {
+    #writer;
+    #log;
+    #provider;
+    #runId;
+    #adapterVersion;
+    #requestIndex = 0;
+    #contextHashCounts = new Map();
+    constructor(deps) {
+        this.#writer = new TraceWriter({ root: deps.root, sessionId: deps.sessionId });
+        this.#log = deps.log;
+        this.#provider = deps.provider;
+        this.#runId = deps.runId;
+        this.#adapterVersion = deps.adapterVersion ?? null;
+    }
+    init() {
+        this.#writer.init();
+    }
+    async *wrap(options, upstream) {
+        const t0 = performance.now();
+        let record = null;
+        try {
+            record = this.#startRecord(options);
+        }
+        catch {
+            record = null; // trace absent; the stream is never affected
+        }
+        // null until the first event; settled to 0 (unknown) only when no
+        // event ever came — a stream whose first event lands in the same
+        // tick records 0, the resolution limit of the "0 = unknown" marker
+        let ttftMs = null;
+        let inputTokens = null;
+        let cacheRead = null;
+        let cacheWrite = null;
+        let outputTokens = null;
+        let usageKnown = false;
+        const toolCalls = [];
+        let outcome = "ok";
+        try {
+            for await (const ev of upstream) {
+                // the null check must be the ONLY guard — a 0-initialized
+                // number never moves (the slice-3 dead-field finding)
+                if (ttftMs === null)
+                    ttftMs = performance.now() - t0;
+                if (ev.type === "tool_call_start")
+                    toolCalls.push(ev.name);
+                if (ev.type === "usage") {
+                    usageKnown = usageKnown || ev.known;
+                    if (ev.inputTokens !== null)
+                        inputTokens = ev.inputTokens;
+                    if (ev.cacheRead !== null)
+                        cacheRead = ev.cacheRead;
+                    if (ev.cacheWrite !== null)
+                        cacheWrite = ev.cacheWrite;
+                    if (ev.outputTokens !== null)
+                        outputTokens = ev.outputTokens;
+                }
+                yield ev;
+            }
+        }
+        catch (err) {
+            outcome = this.#classifyOutcome(err, options);
+            throw err;
+        }
+        finally {
+            if (record !== null) {
+                this.#settle(record, {
+                    outcome,
+                    t0,
+                    ttftMs,
+                    toolCalls,
+                    inputTokens,
+                    cacheRead,
+                    cacheWrite,
+                    outputTokens,
+                    usageKnown,
+                });
+            }
+        }
+    }
+    /** Clean-settle marking for the whole run. */
+    finishRun() {
+        this.#writer.finishRun(this.#runId, this.#requestIndex - 1);
+    }
+    #startRecord(options) {
+        const { systemPrompt, tools, messages } = options;
+        const contextHash = hashContext(systemPrompt, tools, messages);
+        const retryAttempt = this.#contextHashCounts.get(contextHash) ?? 0;
+        this.#contextHashCounts.set(contextHash, retryAttempt + 1);
+        const manifest = buildContextManifest({ log: this.#log, systemPrompt, tools, messages });
+        const hashes = segmentHashes(systemPrompt, tools, messages);
+        return {
+            schemaVersion: TRACE_SCHEMA_VERSION,
+            kind: "request",
+            requestId: randomUUID(),
+            runId: this.#runId,
+            requestIndex: this.#requestIndex++,
+            retryAttempt,
+            provider: this.#provider,
+            model: options.model,
+            adapterVersion: this.#adapterVersion,
+            systemPromptHash: hashSystemPrompt(systemPrompt),
+            toolSchemaHash: hashToolSpecs(tools),
+            contextHash,
+            contextManifest: manifest,
+            // R4b: the per-segment hash LIST rides the record (the break
+            // derivation is analysis-side but needs the list, not the
+            // aggregated fingerprint — slice 5's data source); the
+            // fingerprint covers the CACHEABLE prefix only — the current
+            // turn (freshness fresh) is never part of it (slice 4)
+            segmentHashes: hashes,
+            stablePrefixFingerprint: stablePrefixFingerprint(cacheableHashes(manifest, hashes)),
+            freshInput: 0, // unknown until the usage event — "0 = unknown"
+            cacheRead: 0,
+            cacheWrite: null,
+            output: 0,
+            // the canonical block starts at the same "0 = unknown" convention
+            // and is settled with the quartet (same raw, one derivation)
+            canonical: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: null,
+                reasoning: null,
+                costUsd: 0,
+                pricingTableId: PRICING_TABLE_V1.id,
+                pricingTableVersion: PRICING_TABLE_V1.version,
+            },
+            latencyMs: 0,
+            ttftMs: 0,
+            toolCalls: [],
+            outcome: "ok",
+            ts: Date.now(),
+        };
+    }
+    #settle(record, p) {
+        record.outcome = p.outcome;
+        record.latencyMs = performance.now() - p.t0;
+        record.ttftMs = p.ttftMs ?? 0; // null = no event ever — the "0 = unknown" marker
+        record.toolCalls = p.toolCalls;
+        if (p.usageKnown) {
+            record.freshInput =
+                this.#provider === "anthropic"
+                    ? p.inputTokens ?? 0
+                    : p.inputTokens !== null
+                        ? Math.max(0, p.inputTokens - (p.cacheRead ?? 0))
+                        : 0;
+            record.cacheRead = p.cacheRead ?? 0;
+            record.cacheWrite = p.cacheWrite ?? null;
+            record.output = p.outputTokens ?? 0;
+        }
+        // E2 — the canonical block formalizes the same raw (the route-keyed
+        // mapping; the validator pins block == quartet, so the two can never
+        // drift apart). Unknown usage canonicalizes to the "0 = unknown"
+        // convention, consistent with the quartet above.
+        record.canonical = canonicalizeUsage(this.#provider, {
+            inputTokens: p.inputTokens,
+            outputTokens: p.outputTokens,
+            cacheRead: p.cacheRead,
+            cacheWrite: p.cacheWrite,
+        });
+        this.#writer.enqueue(record);
+    }
+    #classifyOutcome(err, options) {
+        if (options.signal?.aborted === true)
+            return "aborted";
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError" || name === "APIUserAbortError")
+            return "aborted";
+        return "provider_error";
+    }
+}
+/** Wrap the adapter so every stream() call settles a trace record. */
+export function traceGuard(tracer, adapter) {
+    return {
+        stream: (options) => tracer.wrap(options, adapter.stream(options)),
+    };
+}

package/dist/trace/hash.d.ts

@@ -0,0 +1,22 @@
+/**
+ * E1 (1.2.0) — the request hashes (proposal §4, ruling R4b + R1a).
+ *
+ * Every hash is pinned to the schemaVersion's HashSpec (sha-256,
+ * full hex) — `hashSpecFor(TRACE_SCHEMA_VERSION)` is checked at every
+ * call, so a version bump without a re-pin fails loudly instead of
+ * silently changing the algorithm. The canonical serialization is
+ * JSON.stringify of the request-shaped values; the byte discipline is
+ * that the same construction path (the kernel's projection) produces
+ * the same serialization, which the trace-bytes gate pins end-to-end.
+ */
+import type { Message, ToolSpec } from "@vincemakes/kiso-core";
+export declare function sha256Hex(input: string): string;
+export declare const canonicalJson: (v: unknown) => string;
+export declare function hashSystemPrompt(systemPrompt: string | undefined): string;
+export declare function hashToolSpecs(tools: readonly ToolSpec[] | undefined): string;
+/** The full request projection — the same messages array the loop hands
+ *  the adapter, so a retry re-serializes to an IDENTICAL hash (§1.4). */
+export declare function hashContext(systemPrompt: string | undefined, tools: readonly ToolSpec[] | undefined, messages: readonly Message[]): string;
+/** sha-256 over the per-segment hashes of the cacheable prefix — the
+ *  segments up to but NOT including the current turn (R4b). */
+export declare function stablePrefixFingerprint(segmentHashes: readonly string[]): string;

package/dist/trace/hash.js

@@ -0,0 +1,34 @@
+/**
+ * E1 (1.2.0) — the request hashes (proposal §4, ruling R4b + R1a).
+ *
+ * Every hash is pinned to the schemaVersion's HashSpec (sha-256,
+ * full hex) — `hashSpecFor(TRACE_SCHEMA_VERSION)` is checked at every
+ * call, so a version bump without a re-pin fails loudly instead of
+ * silently changing the algorithm. The canonical serialization is
+ * JSON.stringify of the request-shaped values; the byte discipline is
+ * that the same construction path (the kernel's projection) produces
+ * the same serialization, which the trace-bytes gate pins end-to-end.
+ */
+import { createHash } from "node:crypto";
+import { TRACE_SCHEMA_VERSION, hashSpecFor } from "./record.js";
+export function sha256Hex(input) {
+    hashSpecFor(TRACE_SCHEMA_VERSION); // the pinned algorithm, or fail loudly
+    return createHash("sha256").update(input, "utf8").digest("hex");
+}
+export const canonicalJson = (v) => JSON.stringify(v);
+export function hashSystemPrompt(systemPrompt) {
+    return sha256Hex(systemPrompt ?? "");
+}
+export function hashToolSpecs(tools) {
+    return sha256Hex(canonicalJson(tools ?? []));
+}
+/** The full request projection — the same messages array the loop hands
+ *  the adapter, so a retry re-serializes to an IDENTICAL hash (§1.4). */
+export function hashContext(systemPrompt, tools, messages) {
+    return sha256Hex(canonicalJson({ systemPrompt, tools, messages }));
+}
+/** sha-256 over the per-segment hashes of the cacheable prefix — the
+ *  segments up to but NOT including the current turn (R4b). */
+export function stablePrefixFingerprint(segmentHashes) {
+    return sha256Hex(segmentHashes.join(""));
+}

package/dist/trace/manifest.d.ts

@@ -0,0 +1,36 @@
+/**
+ * E1 (1.2.0) — slice 3, the context manifest (proposal §1.3).
+ *
+ * buildContextManifest derives the per-request segment list from the
+ * session log and the request projection. Segments are the system
+ * prompt, the tool schema, then one per user turn. Each turn carries a
+ * THIN seqRange pointer into the event log ([firstSeq, lastSeq] of the
+ * events that produced it) plus an estTokens estimate — the record
+ * never copies payloads (proposal §1.1).
+ *
+ * Turn boundaries are the log's visible user_input events: a VETOED
+ * input (user_input_replaced with null content) is not a boundary — the
+ * model never saw it; a REWRITE keeps the original boundary position
+ * (the projection renders the replacement in place, events.ts:339).
+ * The last turn is current_turn/fresh, earlier turns cache_read; the
+ * system/tools head is cache_read (a stable prefix, R4b).
+ *
+ * When the projection's user-message count and the log's visible
+ * boundary count diverge (a summary replaced whole turns, an alignment
+ * surprise), every turn range degrades to null — honest thin pointers
+ * rather than wrong ones.
+ */
+import type { Event, Message, ToolSpec } from "@vincemakes/kiso-core";
+import type { TraceSegment } from "./record.js";
+export interface ManifestInput {
+    log: readonly Event[];
+    systemPrompt: string | undefined;
+    tools: readonly ToolSpec[] | undefined;
+    messages: readonly Message[];
+}
+export declare function buildContextManifest(input: ManifestInput): TraceSegment[];
+/** Per-segment content hashes for the fingerprint (R4b): the system
+ *  prompt, the tool schema, and each turn's messages, in manifest
+ *  order. The CURRENT turn's hash is the last element — the cacheable
+ *  prefix is everything before it. */
+export declare function segmentHashes(systemPrompt: string | undefined, tools: readonly ToolSpec[] | undefined, messages: readonly Message[]): string[];

package/dist/trace/manifest.js

@@ -0,0 +1,100 @@
+/**
+ * E1 (1.2.0) — slice 3, the context manifest (proposal §1.3).
+ *
+ * buildContextManifest derives the per-request segment list from the
+ * session log and the request projection. Segments are the system
+ * prompt, the tool schema, then one per user turn. Each turn carries a
+ * THIN seqRange pointer into the event log ([firstSeq, lastSeq] of the
+ * events that produced it) plus an estTokens estimate — the record
+ * never copies payloads (proposal §1.1).
+ *
+ * Turn boundaries are the log's visible user_input events: a VETOED
+ * input (user_input_replaced with null content) is not a boundary — the
+ * model never saw it; a REWRITE keeps the original boundary position
+ * (the projection renders the replacement in place, events.ts:339).
+ * The last turn is current_turn/fresh, earlier turns cache_read; the
+ * system/tools head is cache_read (a stable prefix, R4b).
+ *
+ * When the projection's user-message count and the log's visible
+ * boundary count diverge (a summary replaced whole turns, an alignment
+ * surprise), every turn range degrades to null — honest thin pointers
+ * rather than wrong ones.
+ */
+import { estimateTokens } from "@vincemakes/kiso-core";
+import { canonicalJson, hashSystemPrompt, hashToolSpecs, sha256Hex } from "./hash.js";
+/** The log's visible user boundaries, in log order: every user_input
+ *  whose replacement (if any) is not a veto. */
+function visibleBoundaries(log) {
+    const vetoed = new Set();
+    for (const ev of log) {
+        if (ev.type === "user_input_replaced" && ev.content === null)
+            vetoed.add(ev.replaces);
+    }
+    const result = [];
+    for (const ev of log) {
+        if (ev.type === "user_input" && !vetoed.has(ev.seq))
+            result.push(ev.seq);
+    }
+    return result;
+}
+const systemSegment = (systemPrompt) => ({
+    role: "system",
+    seqRange: null,
+    estTokens: estimateTokens([{ role: "user", content: systemPrompt ?? "" }]),
+    freshness: "cache_read",
+});
+const toolsSegment = (tools) => ({
+    role: "tools",
+    seqRange: null,
+    estTokens: estimateTokens([{ role: "tool", callId: "", content: JSON.stringify(tools ?? []), isError: false }]),
+    freshness: "cache_read",
+});
+export function buildContextManifest(input) {
+    const { log, systemPrompt, tools, messages } = input;
+    const boundaries = visibleBoundaries(log);
+    const userCount = messages.filter((m) => m.role === "user").length;
+    const aligned = userCount === boundaries.length;
+    const lastSeq = log.length > 0 ? log[log.length - 1].seq : -1;
+    const segments = [systemSegment(systemPrompt), toolsSegment(tools)];
+    // Partition the projection at user boundaries: partition k runs from
+    // user_k (inclusive) to user_{k+1} (exclusive); messages before the
+    // first user (not produced by the projection today) join partition 0.
+    const userPositions = [];
+    messages.forEach((m, i) => {
+        if (m.role === "user")
+            userPositions.push(i);
+    });
+    for (let k = 0; k < userPositions.length; k++) {
+        const start = k === 0 ? 0 : userPositions[k];
+        const end = k + 1 < userPositions.length ? userPositions[k + 1] : messages.length;
+        const isCurrent = k === userPositions.length - 1;
+        const range = aligned && boundaries[k] !== undefined
+            ? [boundaries[k], k + 1 < boundaries.length ? boundaries[k + 1] - 1 : lastSeq]
+            : null;
+        segments.push({
+            role: isCurrent ? "current_turn" : "turn",
+            seqRange: range,
+            estTokens: estimateTokens(messages.slice(start, end)),
+            freshness: isCurrent ? "fresh" : "cache_read",
+        });
+    }
+    return segments;
+}
+/** Per-segment content hashes for the fingerprint (R4b): the system
+ *  prompt, the tool schema, and each turn's messages, in manifest
+ *  order. The CURRENT turn's hash is the last element — the cacheable
+ *  prefix is everything before it. */
+export function segmentHashes(systemPrompt, tools, messages) {
+    const hashes = [hashSystemPrompt(systemPrompt), hashToolSpecs(tools)];
+    const userPositions = [];
+    messages.forEach((m, i) => {
+        if (m.role === "user")
+            userPositions.push(i);
+    });
+    for (let k = 0; k < userPositions.length; k++) {
+        const start = k === 0 ? 0 : userPositions[k];
+        const end = k + 1 < userPositions.length ? userPositions[k + 1] : messages.length;
+        hashes.push(sha256Hex(canonicalJson(messages.slice(start, end))));
+    }
+    return hashes;
+}

package/dist/trace/record.d.ts

@@ -0,0 +1,129 @@
+/**
+ * E1 (1.2.0) — the Request Trace record schema (proposal §1.1 as adopted
+ * by the R1 ruling: "adopt as-is, keep ts, per-round additive"). This is
+ * the 1.2.0 field-set lock: every field below is spec'd, and the
+ * closed-field-set gate (ruling R1a) pins the shape bidirectionally —
+ * `TRACE_RECORD_FIELDS`/`TRACE_SEGMENT_FIELDS` must stay in exact
+ * agreement with the interfaces, or trace-schema.test.ts goes red.
+ *
+ * R1a: `schemaVersion` pins BOTH the record shape AND the hash /
+ * fingerprint algorithms (`HASH_SPEC_BY_VERSION`). A version bump must
+ * pin a spec for the new version before any writer can use it
+ * (`hashSpecFor` throws otherwise).
+ *
+ * The ledger is OUT-side (ADR-0051 §6): versionable, never part of the
+ * correctness ABI. These types are runtime-internal.
+ *
+ * E2 (1.3.0) — schemaVersion 2: the record gains the `canonical` block
+ * (E2 proposal §1.5 Case A — the nested block, ruled 2026-08-13; raw
+ * quartet stays as provider observation above it). The validators accept
+ * BOTH generations (R1d-1): a v1 sidecar has no canonical block and reads
+ * as defaults at every consumer — never a crash.
+ */
+/** schemaVersion: 2 for 1.3.0 (the canonical block). Version 1 = the 1.2.0
+ *  shape, kept for generation-compat reads (R1d-1). Algorithm and shape
+ *  changes bump it (ADR-0051 §6 OUT-side versioning). */
+export declare const TRACE_SCHEMA_VERSION = 2;
+/** The versions a reader may meet in a ledger. v1 records are accepted
+ *  (generation-compat, R1d-1) and read as defaults — no canonical block. */
+export declare const TRACE_SCHEMA_VERSIONS: Readonly<Set<number>>;
+import type { CanonicalUsage } from "../usage/canonical.js";
+export type Freshness = "fresh" | "cache_read" | "cache_write";
+/** That is the complete set for 1.2.0. */
+export type Outcome = "ok" | "provider_error" | "aborted";
+/** That is the complete set for 1.2.0. (Truncation surfaces as "aborted"
+ *  when the stream ends before settle; refined in E5 if needed.) */
+export interface TraceSegment {
+    role: "system" | "tools" | "turn" | "current_turn";
+    /** Thin pointer into the event log: [firstSeq, lastSeq] inclusive of the
+     *  events that produced this segment. null for system/tools (not events). */
+    seqRange: [number, number] | null;
+    estTokens: number;
+    freshness: Freshness;
+}
+/** That is the complete set for 1.2.0. */
+export interface TraceRecord {
+    schemaVersion: 2;
+    kind: "request";
+    requestId: string;
+    runId: string;
+    requestIndex: number;
+    retryAttempt: number;
+    provider: string;
+    model: string;
+    adapterVersion: string | null;
+    systemPromptHash: string;
+    toolSchemaHash: string;
+    contextHash: string;
+    contextManifest: TraceSegment[];
+    /** Per-segment content hashes, indexed 1:1 with contextManifest
+     *  (segment i's canonical serialization — R4b's analysis-side data
+     *  source: the cache-break derivation needs the LIST, not the
+     *  aggregated fingerprint). Sizing note: 64 hex chars × segments
+     *  per request. */
+    segmentHashes: string[];
+    stablePrefixFingerprint: string;
+    /** The usage quartet is PROVIDER-RAW — never a billing surface.
+     *  Canonical/billing usage lives in the `canonical` block (E2); these
+     *  fields are observation only (a provider may count a token a dozen
+     *  ways; billing must not). */
+    freshInput: number;
+    cacheRead: number;
+    cacheWrite: number | null;
+    output: number;
+    /** E2 — the canonical record of the same raw quartet (the pinned
+     *  sentence: input is FRESH-ONLY; total = input + cacheRead + cacheWrite
+     *  is the derived quantity). Formalizes the quartet by construction —
+     *  the validator pins the equality — and carries the cost from the
+     *  versioned pricing table (every cost records its table version). */
+    canonical: CanonicalUsage;
+    latencyMs: number;
+    ttftMs: number;
+    toolCalls: string[];
+    outcome: Outcome;
+    lineageLink?: {
+        parentSessionId: string;
+        parentRunId: string;
+        parentInvocationSeq: number;
+        role: string;
+    };
+    ts: number;
+}
+/** That is the complete set for 1.2.0. */
+export interface HeaderLine {
+    schemaVersion: 2;
+    kind: "header";
+    sessionId: string;
+    kisoVersion: string;
+    createdAt: number;
+}
+export interface RunEndLine {
+    schemaVersion: 2;
+    kind: "run_end";
+    runId: string;
+    ts: number;
+    lastRequestIndex: number;
+}
+export interface CrashLine {
+    schemaVersion: 2;
+    kind: "crash";
+    ts: number;
+    note: string;
+}
+export type TraceLine = HeaderLine | TraceRecord | RunEndLine | CrashLine;
+export interface HashSpec {
+    readonly algorithm: "sha-256";
+    readonly output: "full-hex";
+}
+export declare const HASH_SPEC_BY_VERSION: Readonly<Record<number, HashSpec>>;
+export declare function hashSpecFor(version: number): HashSpec;
+/** The 1.2.0 field set (schemaVersion 1) — kept verbatim for
+ *  generation-compat reads of old sidecars (R1d-1): a v1 record has no
+ *  canonical block and reads as defaults at every consumer. */
+export declare const TRACE_RECORD_FIELDS_V1: readonly ["schemaVersion", "kind", "requestId", "runId", "requestIndex", "retryAttempt", "provider", "model", "adapterVersion", "systemPromptHash", "toolSchemaHash", "contextHash", "contextManifest", "segmentHashes", "stablePrefixFingerprint", "freshInput", "cacheRead", "cacheWrite", "output", "latencyMs", "ttftMs", "toolCalls", "outcome", "lineageLink", "ts"];
+/** The 1.3.0 field set (schemaVersion 2) = the v1 set + `canonical`. */
+export declare const TRACE_RECORD_FIELDS: readonly ["schemaVersion", "kind", "requestId", "runId", "requestIndex", "retryAttempt", "provider", "model", "adapterVersion", "systemPromptHash", "toolSchemaHash", "contextHash", "contextManifest", "segmentHashes", "stablePrefixFingerprint", "freshInput", "cacheRead", "cacheWrite", "output", "latencyMs", "ttftMs", "toolCalls", "outcome", "lineageLink", "ts", "canonical"];
+export declare const TRACE_SEGMENT_FIELDS: readonly ["role", "seqRange", "estTokens", "freshness"];
+export declare function validateTraceSegment(v: unknown): v is TraceSegment;
+export declare function validateTraceRecord(v: unknown): v is TraceRecord;
+export declare function validateTraceLine(v: unknown): v is TraceLine;