@noopolis/daimon 0.1.0 → 0.1.2

package/dist/pi/piAgentHandle.js

@@ -0,0 +1,324 @@
+import { createTrustedPiMemoryToolContext } from "./memoryTools.js";
+import { formatWakePrompt } from "./prompts.js";
+import { stampTurnInputSubmitted, stampTurnOutputCompleted } from "./turnCausal.js";
+import { WakeAcceptanceStore } from "./wakeAcceptance.js";
+import { persistPiTurnTrace } from "./turnTrace.js";
+import { formatDreamPrompt } from "./wakeModes.js";
+import { createPiRawTrainingCapture } from "./rawTrainingCapture.js";
+import { formatWorldWakePrompt, worldWakeContext } from "./worldNudge.js";
+import { createPiWorldTrajectoryCapture } from "./worldTrajectory.js";
+import { cloneWakeEvent, persistPiTurnArtifacts, PiWakeDeliveryQueue, selectPiSessionForWake, subscribeToPiTurnEvents } from "./piAgentWakeSupport.js";
+import { readMemoryContext } from "@noopolis/mneme";
+export class PiAgentHandle {
+    id;
+    session;
+    createSession;
+    runtimeHomePath;
+    traceModel;
+    memory;
+    memoryToolContext;
+    worldToolContext;
+    rawTrainingCaptureRef;
+    rawTrainingCaptureOptions;
+    worldTrajectoryIdentity;
+    piSessionForRawCapture;
+    state = "idle";
+    lastWakeAt;
+    lastError;
+    wakeDeliveryQueue;
+    stampTurnInputSubmitted;
+    stampTurnOutputCompleted;
+    persistTrace;
+    constructor(id, session, createSession, runtimeHomePath, traceModel, memory, memoryToolContext, dependencies = {}, worldToolContext, rawTrainingCaptureRef, rawTrainingCaptureOptions, worldTrajectoryIdentity, piSessionForRawCapture) {
+        this.id = id;
+        this.session = session;
+        this.createSession = createSession;
+        this.runtimeHomePath = runtimeHomePath;
+        this.traceModel = traceModel;
+        this.memory = memory;
+        this.memoryToolContext = memoryToolContext;
+        this.worldToolContext = worldToolContext;
+        this.rawTrainingCaptureRef = rawTrainingCaptureRef;
+        this.rawTrainingCaptureOptions = rawTrainingCaptureOptions;
+        this.worldTrajectoryIdentity = worldTrajectoryIdentity;
+        this.piSessionForRawCapture = piSessionForRawCapture;
+        this.stampTurnInputSubmitted = dependencies.runWake ?? stampTurnInputSubmitted;
+        this.stampTurnOutputCompleted = dependencies.completeTurn ?? stampTurnOutputCompleted;
+        this.persistTrace = dependencies.traceTurn ?? persistPiTurnTrace;
+        const wakeAcceptance = dependencies.createWakeAcceptance?.(runtimeHomePath, id) ??
+            new WakeAcceptanceStore(runtimeHomePath, id);
+        this.wakeDeliveryQueue = new PiWakeDeliveryQueue(id, wakeAcceptance);
+    }
+    async wake(event) {
+        const wakeEvent = cloneWakeEvent(event);
+        return this.wakeDeliveryQueue.wake(wakeEvent, (queuedEvent, transition) => this.runWake(queuedEvent, transition));
+    }
+    async runWake(event, transitionToInvoking) {
+        const startedAt = new Date();
+        const startedAtMs = Date.now();
+        const chunks = [];
+        const tools = [];
+        let enginePromptMs;
+        let memoryPrepare;
+        let selectedSession;
+        let rawTrainingCapture;
+        let rawTrainingCapturePersistAttempted = false;
+        let unsubscribe;
+        let stage = "select_session";
+        let prepared;
+        this.state = "running";
+        this.lastWakeAt = new Date().toISOString();
+        this.lastError = undefined;
+        const memoryContext = readMemoryContext({
+            kind: event.kind,
+            id: event.id,
+            from: event.from,
+            text: event.text,
+            context: event.context
+        });
+        const worldContext = this.worldToolContext === undefined
+            ? undefined
+            : worldWakeContext(event);
+        const safeWakeText = worldContext === undefined
+            ? event.text
+            : event.kind === "message" && event.delivery !== undefined && event.transportText !== undefined
+                ? `${formatWorldWakePrompt(worldContext)}\n\n${formatWakePrompt(event)}`
+                : formatWorldWakePrompt(worldContext);
+        const worldTrajectory = worldContext?.decisionToken === undefined
+            ? undefined
+            : createPiWorldTrajectoryCapture();
+        const request = {
+            eventId: event.id,
+            kind: event.kind,
+            text: safeWakeText,
+            from: event.from,
+            context: memoryContext
+        };
+        let promptText = worldContext === undefined
+            ? formatWakePrompt(event)
+            : safeWakeText;
+        try {
+            if (this.worldToolContext !== undefined) {
+                this.worldToolContext.current = worldContext;
+            }
+            selectedSession = await selectPiSessionForWake({
+                agentId: this.id,
+                createSession: this.createSession,
+                event,
+                memoryContext,
+                runtimeHomePath: this.runtimeHomePath,
+                session: this.session
+            });
+            if (this.rawTrainingCaptureRef !== undefined
+                && this.rawTrainingCaptureOptions !== undefined) {
+                rawTrainingCapture = createPiRawTrainingCapture();
+                this.rawTrainingCaptureRef.current = rawTrainingCapture;
+            }
+            unsubscribe = subscribeToPiTurnEvents({
+                chunks,
+                rawTrainingCapture,
+                session: selectedSession.session,
+                tools,
+                worldTrajectory
+            });
+            if (this.memory !== undefined) {
+                stage = "memory_prepare";
+                const memoryStartedAt = Date.now();
+                try {
+                    prepared = await this.memory.prepareTurn(request);
+                }
+                catch (error) {
+                    memoryPrepare = {
+                        durationMs: Date.now() - memoryStartedAt,
+                        status: "failed"
+                    };
+                    throw error;
+                }
+                memoryPrepare = {
+                    durationMs: Date.now() - memoryStartedAt,
+                    prepared,
+                    status: "completed"
+                };
+                promptText = prepared.promptText;
+                if (this.memoryToolContext !== undefined) {
+                    this.memoryToolContext.observeTool = (toolEvent) => tools.push(toolEvent);
+                    this.memoryToolContext.current = createTrustedPiMemoryToolContext({
+                        agentId: this.id,
+                        memory: this.memory,
+                        mode: selectedSession.mode,
+                        prepared,
+                        threadId: selectedSession.threadId,
+                        wakeId: event.id
+                    });
+                }
+            }
+            if (selectedSession.mode === "dream") {
+                promptText = formatDreamPrompt(promptText, selectedSession.threadId);
+            }
+            stage = "causal_input";
+            const turnInput = await this.stampTurnInputSubmitted({
+                agentId: this.id,
+                event,
+                prepared,
+                promptText,
+                runtimeHomePath: this.runtimeHomePath
+            });
+            stage = "invoking";
+            if (transitionToInvoking !== undefined) {
+                await transitionToInvoking();
+            }
+            stage = "engine_prompt";
+            const engineStartedAt = Date.now();
+            await selectedSession.session.prompt(promptText, { expandPromptTemplates: false });
+            enginePromptMs = Date.now() - engineStartedAt;
+            this.state = "idle";
+            const outputText = chunks.join("\n").trim();
+            stage = "causal_output";
+            await this.stampTurnOutputCompleted({
+                agentId: this.id,
+                causeEventId: turnInput.event_id,
+                outputText,
+                runtimeHomePath: this.runtimeHomePath,
+                turnId: event.id
+            });
+            await this.persistTrace({
+                agentId: this.id,
+                enginePromptMs,
+                event,
+                memoryPrepare,
+                memoryEnabled: Boolean(this.memory),
+                model: this.traceModel,
+                outputText,
+                promptText,
+                runtimeHomePath: this.runtimeHomePath,
+                session: selectedSession,
+                startedAt,
+                status: "completed",
+                tools,
+                totalMs: Date.now() - startedAtMs,
+                ...(this.worldToolContext === undefined
+                    ? {}
+                    : { worldContextBound: worldContext !== undefined })
+            });
+            if (rawTrainingCapture !== undefined
+                && this.rawTrainingCaptureOptions !== undefined
+                && this.piSessionForRawCapture !== undefined) {
+                // Do not retry a partially failed private capture in the catch path.
+                // The first failure is authoritative and retrying the same immutable
+                // turn path would only mask it with an EEXIST/partial-write error.
+                rawTrainingCapturePersistAttempted = true;
+            }
+            await persistPiTurnArtifacts({
+                agentId: this.id,
+                completedAt: new Date(),
+                model: this.traceModel,
+                piSessionForRawCapture: this.piSessionForRawCapture,
+                promptText,
+                rawTrainingCapture,
+                rawTrainingCaptureOptions: this.rawTrainingCaptureOptions,
+                runtimeHomePath: this.runtimeHomePath,
+                startedAt,
+                status: "completed",
+                totalMs: Date.now() - startedAtMs,
+                turnId: event.id,
+                worldContext,
+                worldTrajectory,
+                worldTrajectoryIdentity: this.worldTrajectoryIdentity
+            });
+            return {
+                agentId: this.id,
+                text: outputText,
+                durationMs: Date.now() - startedAtMs
+            };
+        }
+        catch (error) {
+            this.state = "failed";
+            const message = error instanceof Error ? error.message : String(error);
+            this.lastError = message;
+            if (memoryPrepare === undefined && this.memory !== undefined) {
+                memoryPrepare = {
+                    prepared,
+                    status: "failed"
+                };
+            }
+            await this.persistTrace({
+                agentId: this.id,
+                enginePromptMs,
+                error: {
+                    message,
+                    stage
+                },
+                event,
+                memoryPrepare,
+                memoryEnabled: Boolean(this.memory),
+                model: this.traceModel,
+                outputText: chunks.join("\n").trim(),
+                promptText,
+                runtimeHomePath: this.runtimeHomePath,
+                session: selectedSession,
+                startedAt,
+                status: "failed",
+                tools,
+                totalMs: Date.now() - startedAtMs,
+                ...(this.worldToolContext === undefined
+                    ? {}
+                    : { worldContextBound: worldContext !== undefined })
+            }).catch(() => undefined);
+            const persistRawCapture = !rawTrainingCapturePersistAttempted
+                && selectedSession !== undefined;
+            if (persistRawCapture && rawTrainingCapture !== undefined) {
+                rawTrainingCapturePersistAttempted = true;
+            }
+            await persistPiTurnArtifacts({
+                agentId: this.id,
+                completedAt: new Date(),
+                model: this.traceModel,
+                piSessionForRawCapture: persistRawCapture
+                    ? this.piSessionForRawCapture
+                    : undefined,
+                promptText,
+                rawTrainingCapture: persistRawCapture ? rawTrainingCapture : undefined,
+                rawTrainingCaptureOptions: persistRawCapture
+                    ? this.rawTrainingCaptureOptions
+                    : undefined,
+                runtimeHomePath: this.runtimeHomePath,
+                startedAt,
+                status: "failed",
+                totalMs: Date.now() - startedAtMs,
+                turnId: event.id,
+                worldContext,
+                worldTrajectory,
+                worldTrajectoryIdentity: this.worldTrajectoryIdentity
+            });
+            throw error;
+        }
+        finally {
+            if (this.memoryToolContext !== undefined) {
+                this.memoryToolContext.current = undefined;
+                this.memoryToolContext.observeTool = undefined;
+            }
+            if (this.worldToolContext) {
+                this.worldToolContext.current = undefined;
+            }
+            if (this.rawTrainingCaptureRef) {
+                this.rawTrainingCaptureRef.current = undefined;
+            }
+            unsubscribe?.();
+            if (selectedSession?.disposeAfterWake) {
+                selectedSession.session.dispose();
+            }
+        }
+    }
+    status() {
+        return {
+            agentId: this.id,
+            state: this.state,
+            lastWakeAt: this.lastWakeAt,
+            lastError: this.lastError
+        };
+    }
+    async stop() {
+        this.session.dispose();
+        this.state = "stopped";
+    }
+}

package/dist/pi/piAgentWakeSupport.d.ts

@@ -0,0 +1,68 @@
+import type { createAgentSession } from "@earendil-works/pi-coding-agent";
+import type { WakeMemoryContext, MemoryWakeMode } from "@noopolis/mneme";
+import type { WakeEvent, WakeResult } from "../core/types.js";
+import { type PiRawTrainingCapture, type PiRawTrainingCaptureOptions } from "./rawTrainingCapture.js";
+import { type PiTurnTraceModel, type PiTurnTraceToolEvent } from "./turnTrace.js";
+import type { PiWorldTurnContext } from "./worldNudge.js";
+import { type WakeAcceptanceCapability, type WakeAcceptanceStoreLike } from "./wakeAcceptance.js";
+import { type PiWorldTrajectoryCapture, type PiWorldTrajectoryIdentity } from "./worldTrajectory.js";
+export type PiSession = Awaited<ReturnType<typeof createAgentSession>>["session"];
+export interface PiSessionLike {
+    subscribe(listener: Parameters<PiSession["subscribe"]>[0]): () => void;
+    prompt(text: string, options?: Parameters<PiSession["prompt"]>[1]): Promise<void>;
+    dispose(): void;
+}
+export type PiSessionCreator = (mode: MemoryWakeMode, sessionDirectory: string) => Promise<PiSessionLike>;
+export type PiNativeSessionCreator = (mode: MemoryWakeMode, sessionDirectory: string) => Promise<PiSession>;
+export interface WakeSessionSelection {
+    disposeAfterWake: boolean;
+    mode: MemoryWakeMode;
+    session: PiSessionLike;
+    threadId: string;
+}
+type WakeRunner = (event: WakeEvent, transitionToInvoking?: () => Promise<WakeAcceptanceCapability>) => Promise<WakeResult>;
+export declare class PiWakeDeliveryQueue {
+    private readonly agentId;
+    private readonly acceptance;
+    private queue;
+    private readonly inProgress;
+    constructor(agentId: string, acceptance: WakeAcceptanceStoreLike);
+    wake(event: WakeEvent, run: WakeRunner): Promise<WakeResult>;
+    private enqueue;
+    private runDelivery;
+}
+export declare const cloneWakeEvent: (event: WakeEvent) => WakeEvent;
+export declare const selectPiSessionForWake: (input: {
+    agentId: string;
+    createSession: PiSessionCreator;
+    event: WakeEvent;
+    memoryContext: WakeMemoryContext;
+    runtimeHomePath: string;
+    session: PiSessionLike;
+}) => Promise<WakeSessionSelection>;
+export declare const subscribeToPiTurnEvents: (input: {
+    chunks: string[];
+    rawTrainingCapture?: PiRawTrainingCapture;
+    session: PiSessionLike;
+    tools: PiTurnTraceToolEvent[];
+    worldTrajectory?: PiWorldTrajectoryCapture;
+}) => (() => void);
+export declare const persistPiTurnArtifacts: (input: {
+    agentId: string;
+    completedAt: Date;
+    model: PiTurnTraceModel;
+    piSessionForRawCapture?: PiSession;
+    promptText: string;
+    rawTrainingCapture?: PiRawTrainingCapture;
+    rawTrainingCaptureOptions?: PiRawTrainingCaptureOptions;
+    runtimeHomePath: string;
+    startedAt: Date;
+    status: "completed" | "failed";
+    totalMs: number;
+    turnId: string;
+    worldContext?: PiWorldTurnContext;
+    worldTrajectory?: PiWorldTrajectoryCapture;
+    worldTrajectoryIdentity?: PiWorldTrajectoryIdentity;
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=piAgentWakeSupport.d.ts.map

package/dist/pi/piAgentWakeSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"piAgentWakeSupport.d.ts","sourceRoot":"","sources":["../../src/pi/piAgentWakeSupport.ts"],"names":[],"mappings":"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"}

package/dist/pi/piAgentWakeSupport.js

@@ -0,0 +1,147 @@
+import { capturePiRawTrainingEvent, persistPiRawTrainingCapture, } from "./rawTrainingCapture.js";
+import { summarizeSessionEvent, } from "./turnTrace.js";
+import { createAwakeThreadId, createDreamSessionDirectory, createDreamSessionKey, createDreamThreadId, } from "./wakeModes.js";
+import { WakeAcceptanceError, } from "./wakeAcceptance.js";
+import { capturePiWorldTrajectoryEvent, persistPiWorldTrajectory, } from "./worldTrajectory.js";
+export class PiWakeDeliveryQueue {
+    agentId;
+    acceptance;
+    queue = Promise.resolve();
+    inProgress = new Map();
+    constructor(agentId, acceptance) {
+        this.agentId = agentId;
+        this.acceptance = acceptance;
+    }
+    async wake(event, run) {
+        const candidate = event.delivery === undefined
+            ? undefined
+            : this.acceptance.candidateFromDelivery(event);
+        if (candidate === undefined)
+            return this.enqueue(() => run(event));
+        const active = this.inProgress.get(candidate.identity);
+        if (active !== undefined) {
+            if (active.digest !== candidate.digest) {
+                throw new WakeAcceptanceError("wake_delivery_conflict");
+            }
+            return active.promise;
+        }
+        const queued = this.enqueue(() => this.runDelivery(event, run));
+        const promise = queued.finally(() => {
+            if (this.inProgress.get(candidate.identity)?.promise === promise) {
+                this.inProgress.delete(candidate.identity);
+            }
+        });
+        this.inProgress.set(candidate.identity, { digest: candidate.digest, promise });
+        return promise;
+    }
+    enqueue(run) {
+        const queued = this.queue.then(run, run);
+        this.queue = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    async runDelivery(event, run) {
+        const admission = await this.acceptance.begin(event);
+        if (admission.mode === "replay") {
+            return { agentId: this.agentId, text: "", durationMs: 0 };
+        }
+        let capability = admission.capability;
+        try {
+            const result = await run(event, async () => {
+                capability = await this.acceptance.markInvoking(capability);
+                return capability;
+            });
+            await this.acceptance.markCompleted(capability);
+            return result;
+        }
+        catch (error) {
+            await this.acceptance.markIncomplete(capability).catch(() => undefined);
+            throw error;
+        }
+    }
+}
+const cloneContext = (context) => ({
+    ...context,
+    ...(context?.pairPeers === undefined ? {} : { pairPeers: [...context.pairPeers] }),
+    ...(context?.artifactPaths === undefined ? {} : { artifactPaths: [...context.artifactPaths] }),
+});
+export const cloneWakeEvent = (event) => ({
+    ...event,
+    ...(event.delivery === undefined ? {} : { delivery: { ...event.delivery } }),
+    ...(event.context === undefined ? {} : { context: cloneContext(event.context) }),
+});
+export const selectPiSessionForWake = async (input) => {
+    if (input.event.kind !== "dream") {
+        return {
+            disposeAfterWake: false,
+            mode: "awake",
+            session: input.session,
+            threadId: createAwakeThreadId(input.memoryContext, input.agentId),
+        };
+    }
+    const sessionKey = createDreamSessionKey(input.event);
+    return {
+        disposeAfterWake: true,
+        mode: "dream",
+        session: await input.createSession("dream", createDreamSessionDirectory(input.runtimeHomePath, sessionKey)),
+        threadId: createDreamThreadId(sessionKey),
+    };
+};
+export const subscribeToPiTurnEvents = (input) => {
+    const unsubscribe = input.session.subscribe((event) => {
+        if (input.rawTrainingCapture !== undefined) {
+            capturePiRawTrainingEvent(input.rawTrainingCapture, event);
+        }
+        if (input.worldTrajectory !== undefined) {
+            capturePiWorldTrajectoryEvent(input.worldTrajectory, event);
+        }
+        const toolEvent = summarizeSessionEvent(event);
+        if (toolEvent !== undefined)
+            input.tools.push(toolEvent);
+        if (event.type !== "turn_end" || !("content" in event.message))
+            return;
+        const { content } = event.message;
+        input.chunks.push(typeof content === "string"
+            ? content
+            : content.filter((entry) => entry.type === "text")
+                .map((entry) => entry.text).join(""));
+    });
+    return unsubscribe;
+};
+export const persistPiTurnArtifacts = async (input) => {
+    if (input.rawTrainingCapture !== undefined
+        && input.rawTrainingCaptureOptions !== undefined
+        && input.piSessionForRawCapture !== undefined) {
+        await persistPiRawTrainingCapture({
+            agentId: input.agentId,
+            capture: input.rawTrainingCapture,
+            completedAt: input.completedAt,
+            options: input.rawTrainingCaptureOptions,
+            runtimeHomePath: input.runtimeHomePath,
+            session: input.piSessionForRawCapture,
+            startedAt: input.startedAt,
+            status: input.status,
+            totalMs: input.totalMs,
+            turnId: input.turnId,
+            world: input.worldContext,
+        });
+    }
+    if (input.worldContext !== undefined
+        && input.worldTrajectory !== undefined
+        && input.worldTrajectoryIdentity !== undefined) {
+        await persistPiWorldTrajectory({
+            agentId: input.agentId,
+            capture: input.worldTrajectory,
+            completedAt: input.completedAt,
+            context: input.worldContext,
+            instructions: input.worldTrajectoryIdentity.instructions,
+            model: input.model,
+            promptText: input.promptText,
+            runtimeHomePath: input.runtimeHomePath,
+            startedAt: input.startedAt,
+            status: input.status,
+            thinkingLevel: input.worldTrajectoryIdentity.thinkingLevel,
+            totalMs: input.totalMs,
+            turnId: input.turnId,
+        });
+    }
+};

package/dist/pi/piHarness.d.ts

@@ -1,5 +1,15 @@
+import { createAgentSession } from "@earendil-works/pi-coding-agent";
+import { type MemoryAuthorityConfig } from "@noopolis/mneme";
 import type { AgentHandle, AgentHarnessAdapter, AgentStartInput, HarnessModelSpec } from "../core/types.js";
-export interface PiHarnessOptions {
+import { type PiSessionLike } from "./piAgentHandle.js";
+import { type PiWorldBinding } from "./worldTools.js";
+import { type PiRawTrainingCaptureOptions } from "./rawTrainingCapture.js";
+type HarnessMemoryEmbeddingProvider = {
+    dimensions?: number;
+    embed(text: string): Promise<number[]>;
+};
+export type PiThinkingLevel = NonNullable<NonNullable<Parameters<typeof createAgentSession>[0]>["thinkingLevel"]>;
+type PiHarnessBaseOptions = {
     authPath: string;
     model?: {
         auth?: HarnessModelSpec["auth"];
@@ -8,12 +18,36 @@ export interface PiHarnessOptions {
         name: string;
     };
     modelsPath?: string;
-}
+    memory?: {
+        authority?: MemoryAuthorityConfig;
+        embeddingProvider?: HarnessMemoryEmbeddingProvider;
+        source?: string;
+        tokenBudget?: number;
+        runtimeHomePath?: string;
+    };
+    thinkingLevel?: PiThinkingLevel;
+    world?: PiWorldBinding;
+};
+export type PiHarnessOptions = PiHarnessBaseOptions & ({
+    rawTrainingCapture?: PiRawTrainingCaptureOptions;
+    sessionFactory?: never;
+} | {
+    rawTrainingCapture?: never;
+    sessionFactory: PiSessionFactory;
+});
+export type PiSessionFactoryInput = Exclude<Parameters<typeof createAgentSession>[0], undefined> & {
+    daimonSecretEnvironmentNames?: readonly string[];
+};
+export type PiSessionFactory = (input: PiSessionFactoryInput) => Promise<{
+    session: PiSessionLike;
+}>;
 export declare class PiHarnessAdapter implements AgentHarnessAdapter {
     private readonly options;
     private readonly authStorage;
     private readonly modelRegistry;
+    private readonly sessionFactory;
     constructor(options: PiHarnessOptions);
     startAgent(input: AgentStartInput): Promise<AgentHandle>;
 }
+export {};
 //# sourceMappingURL=piHarness.d.ts.map

package/dist/pi/piHarness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"piHarness.d.ts","sourceRoot":"","sources":["../../src/pi/piHarness.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,eAAe,EAEf,gBAAgB,EAGjB,MAAM,kBAAkB,CAAC;AAM1B,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACxC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA4HD,qBAAa,gBAAiB,YAAW,mBAAmB;IAI9C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;gBAEjB,OAAO,EAAE,gBAAgB;IAKhD,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;CAgC/D"}
+{"version":3,"file":"piHarness.d.ts","sourceRoot":"","sources":["../../src/pi/piHarness.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,kBAAkB,EAInB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAuB,KAAK,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAElF,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAM5G,OAAO,EAAqE,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC3H,OAAO,EAAwC,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE5F,OAAO,EAGL,KAAK,2BAA2B,EAEjC,MAAM,yBAAyB,CAAC;AAEjC,KAAK,8BAA8B,GAAG;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,WAAW,CACvC,WAAW,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CACvE,CAAC;AAEF,KAAK,oBAAoB,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACxC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE;QACP,SAAS,CAAC,EAAE,qBAAqB,CAAC;QAClC,iBAAiB,CAAC,EAAE,8BAA8B,CAAC;QACnD,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,CAClD;IACA,kBAAkB,CAAC,EAAE,2BAA2B,CAAC;IACjD,cAAc,CAAC,EAAE,KAAK,CAAC;CACxB,GACC;IACA,kBAAkB,CAAC,EAAE,KAAK,CAAC;IAC3B,cAAc,EAAE,gBAAgB,CAAC;CAClC,CACF,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG;IACjG,4BAA4B,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,qBAAqB,KAAK,OAAO,CAAC;IAAE,OAAO,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AAErG,qBAAa,gBAAiB,YAAW,mBAAmB;IAK9C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;gBAErB,OAAO,EAAE,gBAAgB;IAMhD,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;CA4I/D"}