@pstdio/sdk 0.20.0 → 0.22.0

package/dist/client/index.d.ts

@@ -1,14 +0,0 @@
-export type { AgentClient } from "./agents";
-export { createClient, type PstdioClient } from "./client";
-export type { ExtensionClient } from "./extensions";
-export type { NotificationsClient } from "./notifications";
-export type { ProjectClient } from "./projects";
-export { type ClientOptions, createRequest, PstdioApiError, type RequestFn, type RequestOptions, } from "./request";
-export { createRuntimeClient, type RuntimeClient } from "./runtime";
-export type { ListSessionsInput, SessionClient, SessionStreamConnection, SessionStreamHandlers } from "./sessions";
-export type { SettingsClient } from "./settings";
-export type { SkillClient } from "./skills";
-export type { SseEvent } from "./sse";
-export { applySyncEvent, parseSyncDeleteEvent, type StartSyncInput, type SyncClient, type SyncConnection, type SyncRow, type SyncWriter, type SyncWriterProvider, } from "./sync";
-export type { TemplateClient } from "./templates";
-export type { WorkspaceClient } from "./workspaces";

package/dist/client/notifications.d.ts

@@ -1,23 +0,0 @@
-import type { CreateNotificationInput, ListNotificationsQuery, ListNotificationsResponse, Notification, NotificationStatus, UpdateNotificationInput } from "pstdio-api-contracts";
-import type { RequestFn } from "./request";
-export type NotificationsClient = {
-    list(projectId: string, query?: ListNotificationsQuery): Promise<ListNotificationsResponse>;
-    count(projectId: string, query?: Pick<ListNotificationsQuery, "status" | "priority" | "sourceExtensionId">): Promise<{
-        count: number;
-    }>;
-    get(projectId: string, id: string): Promise<Notification>;
-    create(input: CreateNotificationInput): Promise<Notification>;
-    update(projectId: string, id: string, input: UpdateNotificationInput): Promise<Notification>;
-    markRead(projectId: string, id: string): Promise<Notification>;
-    dismiss(projectId: string, id: string): Promise<Notification>;
-    markDone(projectId: string, id: string): Promise<Notification>;
-    snooze(projectId: string, id: string, until: string): Promise<Notification>;
-    resolveByDedupeKey(projectId: string, input: {
-        dedupeKey: string;
-        status?: Extract<NotificationStatus, "done" | "dismissed" | "expired">;
-    }): Promise<{
-        resolved: number;
-        notifications: Notification[];
-    }>;
-};
-export declare const createNotificationsClient: (request: RequestFn) => NotificationsClient;

package/dist/client/projects.d.ts

@@ -1,14 +0,0 @@
-import type { CreateProjectInput, ListActivityResponse, ListProjectActivityInput, RegisterRepoInput, Repo } from "pstdio-api-contracts";
-import type { Project } from "../resources";
-import type { RequestFn } from "./request";
-export type ProjectClient = {
-    list(): Promise<Project[]>;
-    get(projectId: string): Promise<Project>;
-    create(input: CreateProjectInput): Promise<Project>;
-    delete(projectId: string): Promise<void>;
-    listActivity(projectId: string, input?: ListProjectActivityInput): Promise<ListActivityResponse>;
-    listRepos(projectId: string): Promise<Repo[]>;
-    registerRepo(projectId: string, input: RegisterRepoInput): Promise<Repo>;
-    removeRepo(projectId: string, repoId: string): Promise<void>;
-};
-export declare const createProjectClient: (request: RequestFn) => ProjectClient;

package/dist/client/request.d.ts

@@ -1,25 +0,0 @@
-export type ClientOptions = {
-    baseUrl?: string;
-    token?: string;
-    fetch?: typeof fetch;
-};
-export declare class PstdioApiError extends Error {
-    status: number;
-    constructor(message: string, status: number);
-}
-export type RequestOptions = {
-    method?: string;
-    body?: unknown;
-    signal?: AbortSignal;
-    headers?: HeadersInit;
-    cache?: RequestCache;
-};
-export type RequestFn = <T>(path: string, options?: RequestOptions) => Promise<T>;
-export declare const resolveBaseUrl: (options: ClientOptions) => string;
-export declare const resolveClientUrl: (baseUrl: string, path: string) => string;
-export declare const resolveFetch: (options: ClientOptions) => typeof fetch;
-export declare const createRequestHeaders: (options: ClientOptions, reqOpts?: {
-    headers?: HeadersInit;
-    hasJsonBody?: boolean;
-}) => Headers;
-export declare const createRequest: (options: ClientOptions) => RequestFn;

package/dist/client/runtime.d.ts

@@ -1,5 +0,0 @@
-import type { RequestFn } from "./request";
-export type RuntimeClient = {
-    provisionBrowserSession: () => Promise<void>;
-};
-export declare const createRuntimeClient: (request: RequestFn) => RuntimeClient;

package/dist/client/sessions.d.ts

@@ -1,45 +0,0 @@
-import type { ApprovalInput, CreateSessionInput, FollowUpInput, FollowUpResponse, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionAttachment, SessionConversationResponse } from "pstdio-api-contracts";
-import type { Session } from "../resources";
-import { type ClientOptions, type RequestFn } from "./request";
-import { type SseEvent } from "./sse";
-export type ListSessionsInput = {
-    status?: string;
-    agent?: string;
-    workspaceId?: string;
-    archived?: boolean;
-};
-export type SessionClient = {
-    list(projectId: string, input?: ListSessionsInput): Promise<Session[]>;
-    get(sessionId: string): Promise<Session>;
-    uploadAttachment(projectId: string, input: {
-        name: string;
-        data: Uint8Array | ArrayBuffer;
-        mimeType?: string | null;
-    }): Promise<SessionAttachment>;
-    deleteAttachment(projectId: string, fileId: string): Promise<void>;
-    create(input: CreateSessionInput): Promise<Session>;
-    archive(sessionId: string): Promise<void>;
-    followUp(sessionId: string, input: FollowUpInput): Promise<FollowUpResponse>;
-    approve(sessionId: string, input: ApprovalInput): Promise<void>;
-    getConversation(sessionId: string): Promise<SessionConversationResponse>;
-    resolveSessionId(input: ResolveSessionIdInput): Promise<ResolveSessionIdResponse>;
-    updateStatus(sessionId: string, status: string): Promise<Session>;
-    listActivity(sessionId: string, input?: ListSessionActivityInput): Promise<ListSessionActivityResponse>;
-    stream(sessionId: string, onEvent: (event: SseEvent) => void, options?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    connectStream(sessionId: string, handlers: SessionStreamHandlers, options?: {
-        attempt?: number;
-    }): SessionStreamConnection;
-};
-export type SessionStreamHandlers = {
-    onReady?: (data: unknown) => void;
-    onPatch?: (data: unknown) => void;
-    onApprovalRequest?: (data: unknown) => void;
-    onEnd?: (data: unknown) => void;
-    onError?: (error: unknown) => void;
-};
-export type SessionStreamConnection = {
-    close: () => void;
-};
-export declare const createSessionClient: (request: RequestFn, clientOptions: ClientOptions) => SessionClient;

package/dist/client/settings.d.ts

@@ -1,7 +0,0 @@
-import type { Settings, UpdateSettingsInput } from "../api/settings";
-import type { RequestFn } from "./request";
-export type SettingsClient = {
-    get(): Promise<Settings>;
-    update(input: UpdateSettingsInput): Promise<Settings>;
-};
-export declare const createSettingsClient: (request: RequestFn) => SettingsClient;

package/dist/client/skills.d.ts

@@ -1,9 +0,0 @@
-import type { UpdateSkillInput } from "../api/skills";
-import type { Skill, SkillWithContent } from "../resources";
-import type { RequestFn } from "./request";
-export type SkillClient = {
-    list(projectId: string): Promise<Skill[]>;
-    get(projectId: string, skillId: string): Promise<SkillWithContent>;
-    updatePreferences(projectId: string, skillName: string, input: UpdateSkillInput): Promise<Skill>;
-};
-export declare const createSkillClient: (request: RequestFn) => SkillClient;

package/dist/client/sse.d.ts

@@ -1,15 +0,0 @@
-export type SseEvent = {
-    event: string;
-    data: string;
-};
-export declare const parseSseEvent: (part: string) => {
-    event: string;
-    data: string;
-} | null;
-export declare const consumeSseBuffer: (buffer: string) => {
-    remainder: string;
-    events: SseEvent[];
-};
-export declare const readSseStream: (body: ReadableStream<Uint8Array>, onEvent: (event: SseEvent) => void, options?: {
-    signal?: AbortSignal;
-}) => Promise<void>;

package/dist/client/sync.d.ts

@@ -1,35 +0,0 @@
-import { type ClientOptions } from "./request";
-export type SyncRow = {
-    id: string;
-    [key: string]: unknown;
-};
-export type SyncWriter = {
-    truncateAndWrite: (rows: SyncRow[]) => void;
-    upsert: (row: SyncRow) => void;
-    remove: (id: string) => void;
-};
-export type SyncWriterProvider = {
-    getWriter: (table: string) => SyncWriter | undefined;
-};
-export type SyncConnection = {
-    close: () => void;
-    connected: boolean;
-};
-export type StartSyncInput = SyncWriterProvider & {
-    onConnected?: () => void;
-    onDisconnected?: () => void;
-    onConnectionLost?: () => void;
-    heartbeatIntervalMs?: number;
-    heartbeatThreshold?: number;
-    reconnectDelayMs?: number;
-};
-export type SyncClient = {
-    start: (input: StartSyncInput) => SyncConnection;
-};
-export declare const parseSyncDeleteEvent: (data: string) => {
-    table: string;
-    id: string;
-    seq: number;
-};
-export declare const applySyncEvent: (event: string, data: string, writers: SyncWriterProvider) => number | null;
-export declare const createSyncClient: (clientOptions: ClientOptions) => SyncClient;

package/dist/client/templates.d.ts

@@ -1,11 +0,0 @@
-import type { CreateTemplateInput, UpdateTemplateInput } from "../api/templates";
-import type { Template, TemplateWithContent } from "../resources";
-import type { RequestFn } from "./request";
-export type TemplateClient = {
-    list(projectId: string): Promise<Template[]>;
-    get(projectId: string, templateId: string): Promise<TemplateWithContent>;
-    create(projectId: string, input: CreateTemplateInput): Promise<Template>;
-    update(projectId: string, templateId: string, input: UpdateTemplateInput): Promise<Template>;
-    delete(projectId: string, templateId: string): Promise<void>;
-};
-export declare const createTemplateClient: (request: RequestFn) => TemplateClient;

package/dist/client/workspaces.d.ts

@@ -1,20 +0,0 @@
-import type { CreateWorkspaceInput, ListWorkspaceActivityInput, ListWorkspaceActivityResponse, ListWorkspaceFilesInput, RemoveWorktreeResponse, RenameWorkspaceInput, WorkspaceFileContent, WorkspaceFileEntry, WorkspaceFilesResponse, WriteWorkspaceFileInput } from "pstdio-api-contracts";
-import type { Workspace, WorkspaceListItem } from "../resources";
-import type { RequestFn } from "./request";
-export type WorkspaceClient = {
-    list(projectId: string): Promise<WorkspaceListItem[]>;
-    getByShorthand(projectId: string, shorthand: string): Promise<Workspace>;
-    create(input: CreateWorkspaceInput): Promise<Workspace>;
-    rename(workspaceId: string, input: RenameWorkspaceInput): Promise<Workspace>;
-    listActivity(workspaceId: string, input?: ListWorkspaceActivityInput): Promise<ListWorkspaceActivityResponse>;
-    listFiles(workspaceId: string, input?: ListWorkspaceFilesInput): Promise<WorkspaceFilesResponse>;
-    createDirectory(workspaceId: string, path: string): Promise<WorkspaceFileEntry>;
-    createFile(workspaceId: string, path: string, input: WriteWorkspaceFileInput): Promise<WorkspaceFileContent>;
-    readFile(workspaceId: string, path: string): Promise<WorkspaceFileContent>;
-    writeFile(workspaceId: string, path: string, input: WriteWorkspaceFileInput): Promise<WorkspaceFileContent>;
-    moveEntry(workspaceId: string, path: string, destinationPath: string): Promise<void>;
-    deleteEntry(workspaceId: string, path: string): Promise<void>;
-    removeWorktree(workspaceId: string): Promise<RemoveWorktreeResponse>;
-    delete(workspaceId: string): Promise<void>;
-};
-export declare const createWorkspaceClient: (request: RequestFn) => WorkspaceClient;

package/dist/extensions/command-outcome.d.ts

@@ -1,5 +0,0 @@
-import type { CommandOutcome } from "pstdio-api-contracts/extension-kernel";
-export type CommandResponse<TResult = unknown> = {
-    outcome: CommandOutcome<TResult>;
-};
-export declare const unwrapCommandOutcome: <TResult>(response: CommandResponse<TResult>, fallbackReason?: string) => TResult;

package/dist/extensions/define-command.d.ts

@@ -1,26 +0,0 @@
-import type { CommandDefinition, HookDefinition, MiddlewareDefinition, ParamObjectSchema, Struct } from "pstdio-api-contracts/extension-kernel";
-/**
- * Define a single command outside an extension's object literal. Use this when commands
- * grow large enough to split into separate files, or when you need to share a command
- * shape across extensions. The `params` schema drives the inferred shape of `ctx.params`.
- *
- * @example
- *   export const sayHello = defineCommand({
- *     title: "Say hello",
- *     params: { name: params.text({ required: true }) },
- *     async run(ctx) {
- *       ctx.params.name; // string
- *     },
- *   });
- */
-export declare const defineCommand: <const TSchema extends ParamObjectSchema | undefined, TResult = unknown>(definition: CommandDefinition<TSchema, TResult>) => CommandDefinition<TSchema, TResult>;
-/**
- * Define middleware for a command. Pass the typed `command` ref (preferred) or
- * `commandId` for cross-extension references where the typed ref isn't importable.
- */
-export declare const defineMiddleware: <TParams extends Struct = Struct, TResult = unknown>(definition: MiddlewareDefinition<TParams, TResult>) => MiddlewareDefinition<TParams, TResult>;
-/**
- * Define a hook for an event. Pass the typed `event` ref (preferred) or `eventId` for
- * cross-extension references where the typed ref isn't importable.
- */
-export declare const defineHook: <TPayload extends Struct = Struct>(definition: HookDefinition<TPayload>) => HookDefinition<TPayload>;

package/dist/extensions/define-extension-view.d.ts

@@ -1,58 +0,0 @@
-/**
- * Guest-side contract for extension webviews. The host (dashboard) loads a small bridge
- * runtime in an iframe, applies theme variables onto the iframe document, then dynamically
- * imports the extension's bundled module and calls `view.mount(mount, host, propsStore)`.
- *
- * Extensions export `defineExtensionView({ render })` as the default export of their entry
- * module. `render` receives the mount element, an RPC handle for invoking host capabilities
- * (e.g. `host.call("commands.execute", …)`), and a subscribable `propsStore` that the host
- * can push updates into.
- */
-export type GuestHost = {
-    call: <TResult = unknown>(method: string, params?: unknown) => Promise<TResult>;
-    /** Subscribe to host-pushed events for a capability scope (e.g. "terminal.session"). */
-    onEvent: (scope: string, handler: (payload: unknown) => void) => () => void;
-    /** Id of the extension that owns this webview. Missing only on hosts older than the bridge that sends it. */
-    extensionId?: string;
-};
-export type PropsStore<TProps = unknown> = {
-    get: () => TProps;
-    subscribe: (listener: (props: TProps) => void) => () => void;
-};
-export interface WebviewFilesClient {
-    pick(opts?: {
-        accept?: string;
-        multiple?: boolean;
-    }): Promise<File[]>;
-    upload(input: {
-        name: string;
-        data: Uint8Array | ArrayBuffer;
-        mimeType?: string;
-        scope?: {
-            type: string;
-            id?: string;
-        };
-    }): Promise<import("pstdio-api-contracts/extension-kernel").ExtensionBlobRef>;
-    list(input?: {
-        scope?: {
-            type: string;
-            id?: string;
-        };
-    }): Promise<import("pstdio-api-contracts/extension-kernel").ExtensionBlobRef[]>;
-    delete(id: string): Promise<void>;
-}
-export type ExtensionViewRenderContext<TProps = unknown> = {
-    mount: HTMLElement;
-    host: GuestHost;
-    files: WebviewFilesClient;
-    propsStore: PropsStore<TProps>;
-    locale: string;
-    t: (key: string, defaultValue?: string, args?: Record<string, unknown>) => string;
-};
-export type ExtensionViewRender<TProps = unknown> = (context: ExtensionViewRenderContext<TProps>) => void | (() => void) | Promise<void | (() => void)>;
-export type ExtensionViewModule<TProps = unknown> = {
-    mount: (mount: HTMLElement, host: GuestHost, propsStore: PropsStore<TProps>) => Promise<() => void> | (() => void) | void;
-};
-export declare const defineExtensionView: <TProps = unknown>(definition: {
-    render: ExtensionViewRender<TProps>;
-}) => ExtensionViewModule<TProps>;

package/dist/extensions/define-extension.d.ts

@@ -1,54 +0,0 @@
-import type { CommandDefinition, ExtensionDefinition, ExtensionSettingProperty, ExtensionSettingsContribution, HookDefinition, MiddlewareDefinition, ParamObjectSchema, ScheduleContribution, Struct } from "pstdio-api-contracts/extension-kernel";
-type CommandSchemas = Record<string, ParamObjectSchema | undefined>;
-type MiddlewareParams = Record<string, Struct>;
-type MiddlewareResults = Record<string, unknown>;
-type HookPayloads = Record<string, Struct>;
-type EmptyMap = Record<string, never>;
-type SettingProperties = Record<string, ExtensionSettingProperty>;
-type EmptySettings = Record<string, never>;
-type SettingValue<TProperty> = TProperty extends {
-    type: "boolean";
-} ? boolean : TProperty extends {
-    type: "number";
-} ? number : TProperty extends {
-    type: "string";
-} ? string : TProperty extends {
-    type: "array";
-} ? unknown[] : TProperty extends {
-    type: "object";
-} ? Record<string, unknown> : unknown;
-export type SettingsMap<TSettings> = TSettings extends {
-    properties: infer TProperties;
-} ? {
-    [K in keyof TProperties & string]: SettingValue<TProperties[K]>;
-} : EmptySettings;
-type CommandDefinitions<TSchemas extends CommandSchemas, TSettings extends Record<string, unknown>> = {
-    [K in keyof TSchemas]: CommandDefinition<TSchemas[K], unknown, TSettings>;
-};
-type MiddlewareDefinitions<TParams extends MiddlewareParams, TResults extends MiddlewareResults> = {
-    [K in keyof TParams]: MiddlewareDefinition<TParams[K], K extends keyof TResults ? TResults[K] : unknown>;
-};
-type HookDefinitions<TPayloads extends HookPayloads> = {
-    [K in keyof TPayloads]: HookDefinition<TPayloads[K]>;
-};
-type ExtensionAuthoringDefinition<TCommandSchemas extends CommandSchemas, TMiddlewareParams extends MiddlewareParams, TMiddlewareResults extends MiddlewareResults, THookPayloads extends HookPayloads, TScheduleParams extends MiddlewareParams, TSettings extends ExtensionSettingsContribution<SettingProperties> | undefined> = Omit<ExtensionDefinition, "commands" | "middlewares" | "hooks" | "schedules" | "settings"> & {
-    settings?: TSettings;
-    commands?: CommandDefinitions<TCommandSchemas, SettingsMap<TSettings>>;
-    middlewares?: MiddlewareDefinitions<TMiddlewareParams, TMiddlewareResults>;
-    hooks?: HookDefinitions<THookPayloads>;
-    schedules?: {
-        [K in keyof TScheduleParams]: ScheduleContribution<TScheduleParams[K]>;
-    };
-};
-/**
- * Identity helper that types the passed contributions. Authors get autocomplete on
- * contributions. Extension identity (id, name, version, description, publisher,
- * engines.pstdio) lives in package.json.
- *
- * @example
- *   export default defineExtension({
- *     commands: { ... },
- *   });
- */
-export declare const defineExtension: <const TCommandSchemas extends CommandSchemas = EmptyMap, const TMiddlewareParams extends MiddlewareParams = EmptyMap, const TMiddlewareResults extends MiddlewareResults = MiddlewareResults, const THookPayloads extends HookPayloads = EmptyMap, const TScheduleParams extends MiddlewareParams = EmptyMap, const TSettings extends ExtensionSettingsContribution<SettingProperties> | undefined = undefined>(extension: ExtensionAuthoringDefinition<TCommandSchemas, TMiddlewareParams, TMiddlewareResults, THookPayloads, TScheduleParams, TSettings>) => ExtensionAuthoringDefinition<TCommandSchemas, TMiddlewareParams, TMiddlewareResults, THookPayloads, TScheduleParams, TSettings> & ExtensionDefinition;
-export {};

package/dist/extensions/index.d.ts

@@ -1,13 +0,0 @@
-export type { CreateNotificationInput, ListNotificationsQuery, ListNotificationsResponse, Notification, NotificationAction, NotificationActionResult, NotificationActorType, NotificationKind, NotificationOrigin, NotificationPriority, NotificationStatus, UpdateNotificationInput, } from "pstdio-api-contracts";
-export type * from "pstdio-api-contracts/extension-kernel";
-export type { CommitPayload, ConflictPayload, MergePayload, RebasePayload, SessionLifecyclePayload, WorkspaceProvisionPayload, WorkspaceType, WorktreeRemovedPayload, } from "pstdio-api-contracts/extension-kernel";
-export { ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES, dockedWorkbenchRegions, EXTENSION_API_VERSION, getWorkbenchModeLayoutTargetPanel, getWorkbenchTargetDefinition, gitEvents, isLocalizedString, type Localizable, type LocalizedString, l10n, packageAsset, projectEvents, projectSlots, sessionEvents, sessionSlots, WEBVIEW_DECLARABLE_CAPABILITIES, WEBVIEW_HOST_CAPABILITIES, WEBVIEW_HOST_CAPABILITY_VERSION, type WorkbenchAttachmentTarget, type WorkbenchContributionKind, type WorkbenchLayoutTarget, type WorkbenchMenuTarget, type WorkbenchModeLayoutTarget, type WorkbenchModePanel, type WorkbenchSettingsScope, type WorkbenchSettingsTarget, type WorkbenchTargetDefinition, type WorkbenchTargetGranularity, type WorkbenchTreeTarget, type WorkbenchViewTarget, workbenchMenuTargets, workbenchModeLayoutTargets, workbenchModePanels, workbenchSettingsScopes, workbenchSettingsTargets, workbenchTargets, workbenchTreeTargets, workbenchViewTargets, workspaceEvents, workspaceSlots, worktreeEvents, } from "pstdio-api-contracts/extension-kernel";
-export { type CommandResponse, unwrapCommandOutcome } from "./command-outcome";
-export { defineCommand, defineHook, defineMiddleware } from "./define-command";
-export { defineExtension } from "./define-extension";
-export { defineExtensionView, type ExtensionViewModule, type ExtensionViewRender, type ExtensionViewRenderContext, type GuestHost, type PropsStore, type WebviewFilesClient, } from "./define-extension-view";
-export { params } from "./params";
-export { commandEvent, commandRef, eventRef } from "./refs";
-export { createTerminalSessionBridge, type TerminalSessionAdapter, type TerminalSessionBridge, type TerminalSessionExit, } from "./terminal-session-bridge";
-export { createWebviewClient, type WebviewClient, type WebviewClientOptions, type WebviewCommandsClient, type WebviewSettingsClient, } from "./webview-client";
-export { matchesResourceWhen } from "./when";

package/dist/extensions/params.d.ts

@@ -1,36 +0,0 @@
-import type { BooleanParam, FilesParam, HarnessParam, JsonParam, ListParam, LongTextParam, MarkdownParam, MultiSelectParam, NumberParam, RepoParam, ResourceParam, SelectParam, TemplateParam, TextParam } from "pstdio-api-contracts/extension-kernel";
-type RequiredOf<TOptions> = TOptions extends {
-    required: infer TRequired extends boolean;
-} ? TRequired : undefined;
-type ParamOptions<TParam extends {
-    type: string;
-}> = Omit<TParam, "type">;
-/**
- * Builders for typed parameter descriptors. Each builder produces a discriminated
- * `ParamDescriptor` so the runtime and editor only see fields valid for that type.
- *
- * @example
- *   params: {
- *     amount: params.number({ defaultValue: 1 }),
- *     mode: params.select({ options: [{ label: "Fast", value: "fast" }] }),
- *   }
- */
-export declare const params: {
-    text: <const TOptions extends ParamOptions<TextParam> | undefined = undefined>(options?: TOptions) => TextParam<RequiredOf<TOptions>>;
-    longText: <const TOptions extends ParamOptions<LongTextParam> | undefined = undefined>(options?: TOptions) => LongTextParam<RequiredOf<TOptions>>;
-    markdown: <const TOptions extends ParamOptions<MarkdownParam> | undefined = undefined>(options?: TOptions) => MarkdownParam<RequiredOf<TOptions>>;
-    files: <const TOptions extends ParamOptions<FilesParam> | undefined = undefined>(options?: TOptions) => FilesParam<RequiredOf<TOptions>>;
-    number: <const TOptions extends ParamOptions<NumberParam> | undefined = undefined>(options?: TOptions) => NumberParam<RequiredOf<TOptions>>;
-    boolean: <const TOptions extends ParamOptions<BooleanParam> | undefined = undefined>(options?: TOptions) => BooleanParam<RequiredOf<TOptions>>;
-    select: <const TOptions extends ParamOptions<SelectParam>>(options: TOptions) => SelectParam<RequiredOf<TOptions>>;
-    multiSelect: <const TOptions extends ParamOptions<MultiSelectParam>>(options: TOptions) => MultiSelectParam<RequiredOf<TOptions>>;
-    repo: <const TOptions extends ParamOptions<RepoParam> | undefined = undefined>(options?: TOptions) => RepoParam<RequiredOf<TOptions>>;
-    harness: <const TOptions extends ParamOptions<HarnessParam> | undefined = undefined>(options?: TOptions) => HarnessParam<RequiredOf<TOptions>>;
-    template: <const TOptions extends Omit<TemplateParam, "type" | "templateType"> & {
-        type: string;
-    }>(options: TOptions) => TemplateParam<RequiredOf<TOptions>>;
-    resource: <const TOptions extends ParamOptions<ResourceParam>>(options: TOptions) => ResourceParam<RequiredOf<TOptions>>;
-    json: <T = unknown, const TOptions extends ParamOptions<JsonParam<T>> | undefined = undefined>(options?: TOptions) => JsonParam<T, RequiredOf<TOptions>>;
-    list: <const TOptions extends ParamOptions<ListParam> | undefined = undefined>(options?: TOptions) => ListParam<RequiredOf<TOptions>>;
-};
-export {};

package/dist/extensions/refs.d.ts

@@ -1,8 +0,0 @@
-import type { CommandLifecycleEventPayload, CommandLifecyclePhase, CommandRef, EventRef, Struct } from "pstdio-api-contracts/extension-kernel";
-export { commandRef, eventRef } from "pstdio-api-contracts/extension-kernel";
-/**
- * Build an `EventRef` for a command lifecycle phase (`requested`, `started`, `completed`,
- * `rejected`, `failed`). The payload type is inferred from the command ref so hooks see
- * the correct shape.
- */
-export declare const commandEvent: <TPhase extends CommandLifecyclePhase, TParams extends Struct = Struct, TResult = unknown>(command: CommandRef<TParams, TResult>, phase: TPhase) => EventRef<CommandLifecycleEventPayload<TPhase, TParams, TResult>>;

package/dist/extensions/terminal-session-bridge.d.ts

@@ -1,32 +0,0 @@
-import type { TerminalSessionRequest } from "../api/terminal";
-import type { GuestHost } from "./define-extension-view";
-export interface TerminalSessionExit {
-    code: number | null;
-    signal: string | null;
-}
-/**
- * Renderer-side session over the `terminal.session` capability. Structurally
- * compatible with the `TerminalSessionAdapter` contract of `@pstdio/ui/terminal`,
- * so it plugs straight into the `Terminal` component's `bridge` prop.
- */
-export interface TerminalSessionAdapter {
-    readonly id: string;
-    write(data: string | Uint8Array): void;
-    resize(cols: number, rows: number): void;
-    kill(signal?: string): Promise<void>;
-    onData(handler: (chunk: Uint8Array) => void): () => void;
-    onExit(handler: (exit: TerminalSessionExit) => void): () => void;
-    onError(handler: (error: {
-        message: string;
-    }) => void): () => void;
-}
-export interface TerminalSessionBridge {
-    openSession(request: TerminalSessionRequest): Promise<TerminalSessionAdapter>;
-}
-/**
- * Builds a terminal bridge for an extension webview from its `GuestHost`.
- * Operations go through `host.call("terminal.session", ...)`; output and exit
- * events arrive through the host event channel. The webview must declare the
- * `terminal.session` capability or every call is rejected by the host gate.
- */
-export declare const createTerminalSessionBridge: (host: GuestHost) => TerminalSessionBridge;

package/dist/extensions/webview-client.d.ts

@@ -1,41 +0,0 @@
-import type { CommandDefinition, ParamObjectSchema, ParamsOf } from "pstdio-api-contracts/extension-kernel";
-import type { SettingsMap } from "./define-extension";
-import type { GuestHost } from "./define-extension-view";
-type CommandFn<TDefinition> = TDefinition extends CommandDefinition<infer TSchema, infer TResult, infer _TSettings> ? TSchema extends ParamObjectSchema ? Partial<ParamsOf<TSchema>> extends ParamsOf<TSchema> ? (params?: ParamsOf<TSchema>) => Promise<TResult> : (params: ParamsOf<TSchema>) => Promise<TResult> : () => Promise<TResult> : never;
-export type WebviewCommandsClient<TCommands> = {
-    [K in keyof TCommands & string]: CommandFn<TCommands[K]>;
-};
-export type WebviewSettingsClient<TSettings> = {
-    all: () => Promise<Partial<TSettings>>;
-    get: <K extends keyof TSettings & string>(key: K) => Promise<TSettings[K] | undefined>;
-    set: <K extends keyof TSettings & string>(key: K, value: TSettings[K]) => Promise<void>;
-};
-type ClientSettingsMap<TSettings> = TSettings extends {
-    properties: unknown;
-} ? SettingsMap<TSettings> : Record<never, never>;
-export type WebviewClient<TCommands, TSettings = undefined> = {
-    commands: WebviewCommandsClient<TCommands>;
-    settings: WebviewSettingsClient<ClientSettingsMap<TSettings>>;
-};
-export interface WebviewClientOptions {
-    /** Overrides the extension id provided by the host bridge (e.g. in tests). */
-    extensionId?: string;
-}
-/**
- * Typed guest-side client over the host bridge. Command params and results come from
- * the extension's exported commands record (`defineCommand` values); settings come
- * from its exported settings contribution. Command outcomes are unwrapped, so
- * failures throw.
- *
- * Import both as types only, so no server code enters the webview bundle:
- *
- * @example
- *   import type { commands } from "../commands";
- *   import type { settings } from "../settings";
- *
- *   const client = createWebviewClient<typeof commands, typeof settings>(host);
- *   const { statuses } = await client.commands["ticketStatus.read"]();
- *   const enabled = await client.settings.get("counter.enabled");
- */
-export declare const createWebviewClient: <TCommands extends object, TSettings = undefined>(host: GuestHost, options?: WebviewClientOptions) => WebviewClient<TCommands, TSettings>;
-export {};

package/dist/extensions/when.d.ts

@@ -1,9 +0,0 @@
-import type { WhenExpression } from "pstdio-api-contracts/extension-kernel";
-/**
- * Resource-scoped visibility for command-palette contributions. Both the workbench host and the
- * dashboard palette gate the same way, so the rule lives here once instead of being re-derived per
- * surface. Only `resourceType` is evaluated: it is the sole `when` field a palette surface can
- * resolve from the active resource alone (`mode`/`source`/`metadata` require execution context the
- * palette does not have).
- */
-export declare const matchesResourceWhen: (when: Pick<WhenExpression, "resourceType"> | undefined, resourceType: string | undefined) => boolean;

package/dist/hooks/base.d.ts

@@ -1,17 +0,0 @@
-import type { FollowUpInput } from "../api/sessions";
-import type { PstdioClient } from "../client";
-import type { Session } from "../resources";
-export type SessionFollowupInput = Omit<FollowUpInput, "template" | "vars">;
-type HookSessionClient = {
-    followup(input: SessionFollowupInput): Promise<Session>;
-};
-export type HookClient = PstdioClient & {
-    session: HookSessionClient;
-};
-export type HookPayload = Record<string, unknown>;
-export type BaseHookContext = {
-    client: HookClient;
-    projectId: string;
-    payload?: HookPayload;
-};
-export {};

package/dist/hooks/entities.d.ts

@@ -1,8 +0,0 @@
-import type { Workspace } from "../resources";
-export type HookResourceAnchor = {
-    type: string;
-    id: string;
-    label?: string;
-    metadata?: Record<string, unknown>;
-};
-export type HookWorkspace = Workspace;

package/dist/hooks/index.d.ts

@@ -1,3 +0,0 @@
-export type { BaseHookContext, HookClient, HookPayload, SessionFollowupInput } from "./base";
-export type { SessionHookContext } from "./session";
-export type { CommitContext, ConflictContext, MergeContext, RebaseContext, WorktreeContext, WorktreeCreateContext, WorktreeRemoveContext, } from "./worktree";

package/dist/hooks/session.d.ts

@@ -1,12 +0,0 @@
-import type { BaseHookContext } from "./base";
-import type { HookResourceAnchor, HookWorkspace } from "./entities";
-export type SessionHookContext = BaseHookContext & {
-    sessionId: string;
-    sessionStatus: "in_progress" | "awaiting_input" | "queued" | "completed" | "failed" | "cancelled" | "disconnected";
-    originalSessionId?: string;
-    workspace?: HookWorkspace;
-    workspaceId?: string;
-    worktreePath?: string;
-    branch?: string;
-    anchors?: HookResourceAnchor[];
-};

package/dist/hooks/worktree.d.ts

@@ -1,53 +0,0 @@
-import type { BaseHookContext } from "./base";
-import type { HookResourceAnchor } from "./entities";
-export type WorktreeCreateContext = BaseHookContext & {
-    repoPath: string;
-    worktreePath: string;
-    branch: string;
-    workspace: string;
-    base: string;
-    anchors?: HookResourceAnchor[];
-};
-export type WorktreeContext = BaseHookContext & {
-    repoPath: string;
-    worktreePath: string;
-    branch: string;
-    workspace: string;
-    workspaceId: string;
-    anchors?: HookResourceAnchor[];
-};
-export type CommitContext = {
-    repoPath: string;
-    worktreePath: string;
-    commitMessage: string;
-    stagePolicy: string;
-    commitSha?: string;
-};
-export type RebaseContext = {
-    repoPath: string;
-    branch: string;
-    target: string;
-};
-export type MergeContext = {
-    repoPath: string;
-    branch: string;
-    target: string;
-    squash: boolean;
-    commitMessage: string | null;
-    commitSha?: string;
-};
-export type ConflictContext = {
-    repoPath: string;
-    branch: string;
-    target: string;
-    operation: "rebase" | "merge";
-};
-export type WorktreeRemoveContext = {
-    repoPath: string;
-    worktreePath: string | null;
-    branch: string;
-    workspace: string;
-    workspaceId: string;
-    anchors?: HookResourceAnchor[];
-    projectId: string;
-};