@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/foundation/structured-agent-runtime/handshake.js

@@ -1,151 +0,0 @@
-import { WORKSPACE_CONTRACT_VERSION, assertStructuredCapability, } from "../../contracts/workspace/index.js";
-import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-export const STRUCTURED_ADAPTER_ENVELOPE = PRODUCT_IDENTITY.protocol.structuredAgentSchema;
-export const STRUCTURED_ADAPTER_ENVELOPE_REVISION = 1;
-export const REQUIRED_STRUCTURED_FEATURES = [
-    "identity.adapter.v1",
-    "commands.correlated.v1",
-    "events.typed.v1",
-    "flow-control.limits.v1",
-];
-export const OPTIONAL_STRUCTURED_FEATURES = [
-    "snapshots.authoritative.v1",
-    "resume.position.v1",
-    "resume.snapshot.v1",
-    "commands.cancellable.v1",
-    "attachments.typed.v1",
-];
-export const STRUCTURED_FLOW_LIMITS = Object.freeze({
-    maxEventBytes: 64 * 1024,
-    maxSnapshotBytes: 1024 * 1024,
-    maxAttachmentBytes: 2 * 1024 * 1024,
-    maxQueuedEvents: 256,
-    maxConcurrentCommands: 4,
-    maxReconnectEvents: 1024,
-});
-export function localStructuredAdapterHello() {
-    return {
-        envelope: STRUCTURED_ADAPTER_ENVELOPE,
-        envelopeRevision: STRUCTURED_ADAPTER_ENVELOPE_REVISION,
-        requiredFeatures: REQUIRED_STRUCTURED_FEATURES,
-        optionalFeatures: OPTIONAL_STRUCTURED_FEATURES,
-        flowLimits: STRUCTURED_FLOW_LIMITS,
-    };
-}
-export function negotiateStructuredAdapter(value, server = localStructuredAdapterHello()) {
-    if (!isStructuredAdapterHello(value)) {
-        return reject("invalid-message", [], [], "adapter hello is malformed or omits required identity, feature, or capability fields");
-    }
-    if (value.envelope !== server.envelope || value.envelopeRevision !== server.envelopeRevision) {
-        return reject("unsupported-version", [], [], `structured adapter envelope mismatch: adapter ${String(value.envelope)}/${String(value.envelopeRevision)}; ${PRODUCT_TEXT.displayName} ${server.envelope}/${server.envelopeRevision}`);
-    }
-    if (!isValidIdentityText(value.adapterId) || !isValidBuildId(value.buildId)) {
-        return reject("invalid-identity", [], [], "adapter identity and build identity must be bounded non-empty values");
-    }
-    if (value.capability.adapterId !== value.adapterId) {
-        return reject("invalid-identity", [], [], "adapter capability identity must match the hello identity");
-    }
-    try {
-        assertStructuredCapability(value.capability);
-    }
-    catch (error) {
-        return reject("invalid-capability", [], [], `adapter capability is invalid: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const advertised = featureSet(value.requiredFeatures, value.optionalFeatures);
-    if (advertised.error)
-        return advertised.error;
-    const serverFeatures = new Set([...server.requiredFeatures, ...server.optionalFeatures]);
-    const adapterRequired = new Set(value.requiredFeatures);
-    const unknownRequired = [...adapterRequired].filter(feature => !serverFeatures.has(feature));
-    if (unknownRequired.length > 0) {
-        return reject("unsupported-feature", [], unknownRequired.sort(), `adapter requires unsupported structured features: ${unknownRequired.sort().join(", ")}`);
-    }
-    const missingFromAdapter = server.requiredFeatures.filter(feature => !advertised.features.has(feature)).sort();
-    const missingFromServer = [...adapterRequired].filter(feature => !serverFeatures.has(feature)).sort();
-    if (missingFromAdapter.length > 0 || missingFromServer.length > 0) {
-        return reject("incompatible-features", missingFromAdapter, missingFromServer, `required structured features are unavailable; adapter missing [${missingFromAdapter.join(", ")}], ${PRODUCT_TEXT.displayName} missing [${missingFromServer.join(", ")}]`);
-    }
-    const capabilityFeatures = requiredFeaturesForCapability(value.capability);
-    const undeclared = capabilityFeatures.filter(feature => !advertised.features.has(feature));
-    if (undeclared.length > 0) {
-        return reject("invalid-capability", undeclared.sort(), [], `adapter capability requires undeclared features: ${undeclared.sort().join(", ")}`);
-    }
-    const negotiatedFeatures = [...advertised.features].filter(feature => serverFeatures.has(feature)).sort();
-    const capability = {
-        ...value.capability,
-        adapterId: value.adapterId,
-        flow: negotiateFlow(value.capability.flow, server.flowLimits),
-    };
-    return {
-        accepted: true,
-        adapterId: value.adapterId,
-        negotiatedFeatures,
-        capability,
-        diagnostic: `structured adapter ready; negotiated ${negotiatedFeatures.join(", ")}`,
-    };
-}
-function requiredFeaturesForCapability(capability) {
-    const features = [];
-    if (capability.snapshots === "authoritative")
-        features.push("snapshots.authoritative.v1");
-    if (capability.resume === "position")
-        features.push("resume.position.v1");
-    if (capability.resume === "snapshot")
-        features.push("resume.snapshot.v1");
-    if (capability.cancellation === "correlated")
-        features.push("commands.cancellable.v1");
-    if (capability.attachmentTypes.length > 0)
-        features.push("attachments.typed.v1");
-    return features;
-}
-function negotiateFlow(adapter, server) {
-    return Object.freeze({
-        maxEventBytes: Math.min(adapter.maxEventBytes, server.maxEventBytes),
-        maxSnapshotBytes: Math.min(adapter.maxSnapshotBytes, server.maxSnapshotBytes),
-        maxAttachmentBytes: Math.min(adapter.maxAttachmentBytes, server.maxAttachmentBytes),
-        maxQueuedEvents: Math.min(adapter.maxQueuedEvents, server.maxQueuedEvents),
-        maxConcurrentCommands: Math.min(adapter.maxConcurrentCommands, server.maxConcurrentCommands),
-        maxReconnectEvents: Math.min(adapter.maxReconnectEvents, server.maxReconnectEvents),
-    });
-}
-function isStructuredAdapterHello(value) {
-    if (!isRecord(value))
-        return false;
-    return typeof value.envelope === "string"
-        && typeof value.envelopeRevision === "number"
-        && typeof value.adapterId === "string"
-        && typeof value.buildId === "string"
-        && isStringArray(value.requiredFeatures)
-        && isStringArray(value.optionalFeatures)
-        && isRecord(value.capability)
-        && value.capability.kind === "structured"
-        && typeof value.capability.protocolVersion === "number";
-}
-function featureSet(required, optional) {
-    const features = new Set();
-    for (const feature of [...required, ...optional]) {
-        if (!isValidIdentityText(feature)) {
-            return { features, error: reject("invalid-message", [], [], `structured feature name is invalid: ${feature}`) };
-        }
-        if (features.has(feature)) {
-            return { features, error: reject("invalid-message", [], [], `structured feature is declared more than once: ${feature}`) };
-        }
-        features.add(feature);
-    }
-    return { features, error: null };
-}
-function reject(code, missingFromAdapter, missingFromServer, diagnostic) {
-    return { accepted: false, code, missingFromAdapter, missingFromServer, diagnostic };
-}
-function isValidIdentityText(value) {
-    return value.length > 0 && value.length <= 128 && !value.includes("\0");
-}
-function isValidBuildId(value) {
-    return value.length > 0 && value.length <= 256 && !value.includes("\0");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every(item => typeof item === "string");
-}

package/dist/foundation/structured-agent-runtime/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./backpressure.js";
-export * from "./commands.js";
-export * from "./handshake.js";
-export * from "./reconnection.js";
-export * from "./state.js";

package/dist/foundation/structured-agent-runtime/index.js

@@ -1,5 +0,0 @@
-export * from "./backpressure.js";
-export * from "./commands.js";
-export * from "./handshake.js";
-export * from "./reconnection.js";
-export * from "./state.js";

package/dist/foundation/structured-agent-runtime/reconnection.d.ts

@@ -1,38 +0,0 @@
-import { type AgentRecoveryAuthority, type StructuredAgentSnapshot, type StructuredCapabilityContract, type StructuredRecoveryAuthority } from "../../contracts/workspace/index.js";
-import { StructuredEventReducer, type StructuredRuntimeView } from "./state.js";
-export interface StructuredResumeProof {
-    readonly protocolVersion: number;
-    readonly agentId: string;
-    readonly adapterId: string;
-    readonly processIdentity: string;
-    readonly ownershipProof: string;
-    readonly boundary: {
-        readonly kind: "position";
-        readonly position: number;
-        readonly resumeToken: string;
-    } | {
-        readonly kind: "snapshot";
-        readonly snapshotId: string;
-        readonly snapshot: StructuredAgentSnapshot;
-    };
-}
-export type StructuredReconnectionResult = {
-    readonly kind: "accepted";
-    readonly boundary: StructuredRecoveryAuthority["boundary"];
-    readonly view: StructuredRuntimeView | null;
-    readonly diagnostic: string;
-} | {
-    readonly kind: "terminated";
-    readonly reason: "non-reconnectable";
-    readonly diagnostic: string;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-/** Accepts a recovery boundary once after validating negotiated identity, proof, and protocol continuity. */
-export declare class StructuredReconnectionManager {
-    #private;
-    constructor(capability: StructuredCapabilityContract);
-    resume(authorityValue: AgentRecoveryAuthority, proof: StructuredResumeProof, reducer?: StructuredEventReducer | null): StructuredReconnectionResult;
-}

package/dist/foundation/structured-agent-runtime/reconnection.js

@@ -1,130 +0,0 @@
-import { WORKSPACE_CONTRACT_VERSION, assertRecoveryAuthority, assertStructuredAgentSnapshot, assertStructuredCapability, } from "../../contracts/workspace/index.js";
-import { StructuredEventReducer } from "./state.js";
-/** Accepts a recovery boundary once after validating negotiated identity, proof, and protocol continuity. */
-export class StructuredReconnectionManager {
-    #capability;
-    #acceptedBoundaries = new Set();
-    constructor(capability) {
-        assertStructuredCapability(capability);
-        this.#capability = capability;
-    }
-    resume(authorityValue, proof, reducer = null) {
-        let authority;
-        try {
-            assertRecoveryAuthority(authorityValue);
-            authority = authorityValue;
-        }
-        catch (error) {
-            return rejected("invalid-authority", error);
-        }
-        if (authority.kind !== "structured")
-            return rejected("invalid-authority", new Error("structured reconnection requires structured recovery authority"));
-        if (this.#capability.resume === "none") {
-            return { kind: "terminated", reason: "non-reconnectable", diagnostic: "adapter did not negotiate reconnection; durable agent is ended after restart" };
-        }
-        if (this.#capability.resume !== authority.boundary.kind) {
-            return rejected("unsupported-resume", new Error(`persisted ${authority.boundary.kind} recovery is unavailable from negotiated ${this.#capability.resume} resume`));
-        }
-        const identityError = verifyIdentity(authority, proof);
-        if (identityError)
-            return identityError;
-        if (proof.protocolVersion !== WORKSPACE_CONTRACT_VERSION) {
-            return rejected("version-mismatch", new Error(`resume protocol ${proof.protocolVersion} does not match supported version ${WORKSPACE_CONTRACT_VERSION}`));
-        }
-        if (proof.boundary.kind !== authority.boundary.kind) {
-            return rejected("boundary-mismatch", new Error("resume proof boundary does not match the persisted recovery boundary"));
-        }
-        const boundaryKey = boundaryKeyOf(authority.boundary);
-        if (this.#acceptedBoundaries.has(boundaryKey)) {
-            return rejected("replay-detected", new Error("structured recovery boundary has already been accepted"));
-        }
-        if (authority.boundary.kind === "position") {
-            if (proof.boundary.kind !== "position")
-                return rejected("boundary-mismatch", new Error("position resume requires a position proof"));
-            if (proof.boundary.position !== authority.boundary.position) {
-                return rejected("boundary-mismatch", new Error("resume position does not match the persisted recovery boundary"));
-            }
-            if (proof.boundary.resumeToken !== authority.boundary.resumeToken) {
-                return rejected("stale-token", new Error("resume token does not match the persisted recovery boundary"));
-            }
-            let view = null;
-            if (reducer) {
-                const restored = restorePosition(reducer, authority.agentId, proof.boundary.position);
-                if (isRejected(restored))
-                    return restored;
-                view = restored;
-            }
-            this.#acceptedBoundaries.add(boundaryKey);
-            return { kind: "accepted", boundary: authority.boundary, view, diagnostic: "structured resume position verified" };
-        }
-        if (proof.boundary.kind !== "snapshot")
-            return rejected("boundary-mismatch", new Error("snapshot resume requires a snapshot proof"));
-        if (proof.boundary.snapshotId !== authority.boundary.snapshotId) {
-            return rejected("stale-token", new Error("resume snapshot identity does not match the persisted recovery boundary"));
-        }
-        if (payloadBytes(proof.boundary.snapshot.payload) > this.#capability.flow.maxSnapshotBytes) {
-            return rejected("snapshot-too-large", new Error(`resume snapshot exceeds the negotiated ${this.#capability.flow.maxSnapshotBytes} byte limit`));
-        }
-        const snapshotResult = verifySnapshot(authority.agentId, proof.boundary.snapshotId, proof.boundary.snapshot);
-        if (snapshotResult)
-            return snapshotResult;
-        if (reducer) {
-            const applied = reducer.replaceWithSnapshot(proof.boundary.snapshot);
-            if (applied.kind !== "snapshot-applied") {
-                return rejected("snapshot-recovery-failed", new Error(`snapshot recovery failed: ${applied.kind}`));
-            }
-            this.#acceptedBoundaries.add(boundaryKey);
-            return { kind: "accepted", boundary: authority.boundary, view: applied.view, diagnostic: "structured snapshot recovery verified" };
-        }
-        this.#acceptedBoundaries.add(boundaryKey);
-        return { kind: "accepted", boundary: authority.boundary, view: null, diagnostic: "structured snapshot recovery verified" };
-    }
-}
-function verifyIdentity(authority, proof) {
-    if (proof.agentId !== authority.agentId)
-        return rejected("agent-mismatch", new Error("resume proof agent does not match the durable agent identity"));
-    if (proof.adapterId !== authority.adapterId)
-        return rejected("adapter-mismatch", new Error("resume proof adapter does not match the durable adapter identity"));
-    if (proof.processIdentity !== authority.processIdentity)
-        return rejected("process-mismatch", new Error("resume proof process does not match verified process ownership"));
-    if (proof.ownershipProof !== authority.ownershipProof)
-        return rejected("proof-mismatch", new Error("resume ownership proof does not match the persisted authority"));
-    return null;
-}
-function verifySnapshot(agentId, snapshotId, snapshot) {
-    try {
-        assertStructuredAgentSnapshot(snapshot);
-    }
-    catch (error) {
-        return rejected("invalid-snapshot", error);
-    }
-    if (snapshot.snapshotId !== snapshotId)
-        return rejected("invalid-snapshot", new Error("snapshot payload identity does not match the resume boundary"));
-    if (snapshot.agentId !== agentId)
-        return rejected("agent-mismatch", new Error("snapshot payload agent does not match the durable agent identity"));
-    return null;
-}
-function restorePosition(reducer, agentId, position) {
-    if (reducer.agentId !== agentId)
-        return rejected("agent-mismatch", new Error("resume reducer agent does not match the durable agent identity"));
-    try {
-        return reducer.restoreResumeBoundary(position);
-    }
-    catch (error) {
-        return rejected("invalid-authority", error);
-    }
-}
-function boundaryKeyOf(boundary) {
-    return boundary.kind === "position"
-        ? `position:${boundary.position}:${boundary.resumeToken}`
-        : `snapshot:${boundary.snapshotId}`;
-}
-function isRejected(value) {
-    return "kind" in value && value.kind === "rejected";
-}
-function payloadBytes(payload) {
-    return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}

package/dist/foundation/structured-agent-runtime/state.d.ts

@@ -1,57 +0,0 @@
-import { type StructuredAgentSnapshot, type StructuredCapabilityContract, type WorkspaceEvent } from "../../contracts/workspace/index.js";
-export type StructuredAgentEvent = Extract<WorkspaceEvent, {
-    readonly type: "structured-event";
-}>;
-export interface StructuredRuntimeView {
-    readonly agentId: string;
-    readonly revision: number;
-    readonly lastAppliedPosition: number | null;
-    readonly nextEventPosition: number;
-    readonly appliedEventCount: number;
-    readonly lastEventType: string | null;
-    readonly lastEventPayload: unknown;
-    readonly snapshotId: string | null;
-    readonly snapshotPayload: unknown;
-}
-export type StructuredEventApplyResult = {
-    readonly kind: "applied";
-    readonly view: StructuredRuntimeView;
-} | {
-    readonly kind: "duplicate";
-    readonly view: StructuredRuntimeView;
-    readonly duplicatePosition: number;
-} | {
-    readonly kind: "resynchronization-required";
-    readonly view: StructuredRuntimeView;
-    readonly expectedPosition: number;
-    readonly receivedPosition: number;
-    readonly recovery: "snapshot" | "none";
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export type StructuredSnapshotApplyResult = {
-    readonly kind: "snapshot-applied";
-    readonly view: StructuredRuntimeView;
-} | {
-    readonly kind: "snapshot-stale";
-    readonly view: StructuredRuntimeView;
-    readonly currentPosition: number;
-    readonly snapshotPosition: number;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-/** Applies ordered structured events and snapshots while exposing gaps as explicit resynchronization. */
-export declare class StructuredEventReducer {
-    #private;
-    readonly agentId: string;
-    constructor(agentId: string, capability: StructuredCapabilityContract);
-    applyEvent(event: StructuredAgentEvent): StructuredEventApplyResult;
-    replaceWithSnapshot(snapshot: StructuredAgentSnapshot): StructuredSnapshotApplyResult;
-    restoreResumeBoundary(position: number): StructuredRuntimeView;
-    nextEventPosition(): number;
-    view(): StructuredRuntimeView;
-}

package/dist/foundation/structured-agent-runtime/state.js

@@ -1,119 +0,0 @@
-import { assertStructuredAgentSnapshot, assertStructuredCapability, assertWorkspaceEvent, } from "../../contracts/workspace/index.js";
-/** Applies ordered structured events and snapshots while exposing gaps as explicit resynchronization. */
-export class StructuredEventReducer {
-    agentId;
-    #capability;
-    #lastAppliedPosition = null;
-    #appliedEventCount = 0;
-    #revision = 0;
-    #lastEventType = null;
-    #lastEventPayload = null;
-    #snapshotId = null;
-    #snapshotPayload = null;
-    constructor(agentId, capability) {
-        this.agentId = agentId;
-        assertStructuredCapability(capability);
-        if (!agentId || agentId.includes("\0"))
-            throw new TypeError("structured reducer agent id is invalid");
-        this.#capability = capability;
-    }
-    applyEvent(event) {
-        try {
-            assertWorkspaceEvent(event);
-        }
-        catch (error) {
-            return rejected("malformed-event", error);
-        }
-        if (event.agentId !== this.agentId) {
-            return rejected("agent-mismatch", new Error("structured event agent does not match the reducer identity"));
-        }
-        if (!this.#capability.eventTypes.includes(event.eventType)) {
-            return rejected("unsupported-event-type", new Error(`structured event type is not negotiated: ${event.eventType}`));
-        }
-        if (payloadBytes(event.payload) > this.#capability.flow.maxEventBytes) {
-            return rejected("event-too-large", new Error(`structured event exceeds the negotiated ${this.#capability.flow.maxEventBytes} byte limit`));
-        }
-        const nextPosition = this.nextEventPosition();
-        if (event.position < nextPosition) {
-            return { kind: "duplicate", view: this.view(), duplicatePosition: event.position };
-        }
-        if (event.position > nextPosition) {
-            return {
-                kind: "resynchronization-required",
-                view: this.view(),
-                expectedPosition: nextPosition,
-                receivedPosition: event.position,
-                recovery: this.#capability.snapshots === "authoritative" ? "snapshot" : "none",
-            };
-        }
-        this.#lastAppliedPosition = event.position;
-        this.#appliedEventCount += 1;
-        this.#lastEventType = event.eventType;
-        this.#lastEventPayload = event.payload;
-        this.#revision += 1;
-        return { kind: "applied", view: this.view() };
-    }
-    replaceWithSnapshot(snapshot) {
-        if (this.#capability.snapshots !== "authoritative") {
-            return rejected("snapshots-unsupported", new Error("the negotiated adapter capability does not provide authoritative snapshots"));
-        }
-        try {
-            assertStructuredAgentSnapshot(snapshot);
-        }
-        catch (error) {
-            return rejected("malformed-snapshot", error);
-        }
-        if (snapshot.agentId !== this.agentId) {
-            return rejected("agent-mismatch", new Error("structured snapshot agent does not match the reducer identity"));
-        }
-        if (payloadBytes(snapshot.payload) > this.#capability.flow.maxSnapshotBytes) {
-            return rejected("snapshot-too-large", new Error(`structured snapshot exceeds the negotiated ${this.#capability.flow.maxSnapshotBytes} byte limit`));
-        }
-        const currentPosition = this.#lastAppliedPosition;
-        if (currentPosition !== null && snapshot.position < currentPosition) {
-            return { kind: "snapshot-stale", view: this.view(), currentPosition, snapshotPosition: snapshot.position };
-        }
-        this.#lastAppliedPosition = snapshot.position;
-        this.#appliedEventCount = 0;
-        this.#lastEventType = null;
-        this.#lastEventPayload = null;
-        this.#snapshotId = snapshot.snapshotId;
-        this.#snapshotPayload = snapshot.payload;
-        this.#revision += 1;
-        return { kind: "snapshot-applied", view: this.view() };
-    }
-    restoreResumeBoundary(position) {
-        if (!Number.isSafeInteger(position) || position < 0)
-            throw new RangeError("structured resume position must be a non-negative safe integer");
-        this.#lastAppliedPosition = position;
-        this.#appliedEventCount = 0;
-        this.#lastEventType = null;
-        this.#lastEventPayload = null;
-        this.#snapshotId = null;
-        this.#snapshotPayload = null;
-        this.#revision += 1;
-        return this.view();
-    }
-    nextEventPosition() {
-        return this.#lastAppliedPosition === null ? 0 : this.#lastAppliedPosition + 1;
-    }
-    view() {
-        return Object.freeze({
-            agentId: this.agentId,
-            revision: this.#revision,
-            lastAppliedPosition: this.#lastAppliedPosition,
-            nextEventPosition: this.nextEventPosition(),
-            appliedEventCount: this.#appliedEventCount,
-            lastEventType: this.#lastEventType,
-            lastEventPayload: this.#lastEventPayload,
-            snapshotId: this.#snapshotId,
-            snapshotPayload: this.#snapshotPayload,
-        });
-    }
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}
-function payloadBytes(payload) {
-    return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
-}

package/dist/integrations/pi/components/upstream/components/custom-entry.d.ts

@@ -1,17 +0,0 @@
-import { Container } from "#pi-tui";
-import type { CustomEntry, EntryRenderer } from "@earendil-works/pi-coding-agent";
-/**
- * Component that renders a custom session entry from extensions.
- * The host owns transcript spacing; renderer output should provide only its content.
- */
-export declare class CustomEntryComponent extends Container {
-    private entry;
-    private renderer;
-    private customComponent;
-    private _expanded;
-    constructor(entry: CustomEntry<unknown>, renderer: EntryRenderer);
-    hasContent(): boolean;
-    setExpanded(expanded: boolean): void;
-    invalidate(): void;
-    private rebuild;
-}

package/dist/integrations/pi/components/upstream/components/custom-entry.js

@@ -1,51 +0,0 @@
-import { Box, Container, Spacer, Text } from "#pi-tui";
-import { piTheme } from "../theme/theme.js";
-/**
- * Component that renders a custom session entry from extensions.
- * The host owns transcript spacing; renderer output should provide only its content.
- */
-export class CustomEntryComponent extends Container {
-    entry;
-    renderer;
-    customComponent;
-    _expanded = false;
-    constructor(entry, renderer) {
-        super();
-        this.entry = entry;
-        this.renderer = renderer;
-        this.rebuild();
-    }
-    hasContent() {
-        return this.customComponent !== undefined;
-    }
-    setExpanded(expanded) {
-        if (this._expanded !== expanded) {
-            this._expanded = expanded;
-            this.rebuild();
-        }
-    }
-    invalidate() {
-        super.invalidate();
-        this.rebuild();
-    }
-    rebuild() {
-        this.clear();
-        this.customComponent = undefined;
-        let component;
-        try {
-            component = this.renderer(this.entry, { expanded: this._expanded }, piTheme());
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const box = new Box(1, 1, (text) => piTheme().bg("customMessageBg", text));
-            box.addChild(new Text(piTheme().fg("error", `[${this.entry.customType}] renderer failed: ${message}`), 0, 0));
-            component = box;
-        }
-        if (!component) {
-            return;
-        }
-        this.customComponent = component;
-        this.addChild(new Spacer(1));
-        this.addChild(component);
-    }
-}

package/dist/integrations/pi/components/upstream/components/first-time-setup.d.ts

@@ -1,24 +0,0 @@
-import { Container } from "#pi-tui";
-export type TerminalTheme = "dark" | "light";
-export interface FirstTimeSetupResult {
-    theme: TerminalTheme;
-    shareAnalytics: boolean;
-}
-export interface FirstTimeSetupOptions {
-    detectedTheme: TerminalTheme;
-    onThemePreview: (themeName: TerminalTheme) => void;
-    onSubmit: (result: FirstTimeSetupResult) => void;
-    onCancel: () => void;
-}
-/** First-time setup dialog: theme choice and analytics opt-in. */
-export declare class FirstTimeSetupComponent extends Container {
-    private step;
-    private themeIndex;
-    private analyticsIndex;
-    private readonly options;
-    constructor(options: FirstTimeSetupOptions);
-    private update;
-    private addOptionList;
-    private moveSelection;
-    handleInput(keyData: string): void;
-}