@pstdio/sdk 0.3.0 → 0.4.2

package/dist/api/sessions.d.ts

@@ -1 +1 @@
-export type { ApprovalInput, CreateSessionInput, FollowUpInput, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "pstdio-api-contracts";
+export type { ApprovalInput, CreateSessionInput, FollowUpInput, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse, } from "pstdio-api-contracts";

package/dist/api/tickets.d.ts

@@ -1,4 +1,4 @@
-export type { CreateTicketAttemptInput, CreateTicketInput, TicketAttemptMode, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput, } from "pstdio-api-contracts";
+export type { CreateTicketAttemptInput, CreateTicketInput, ListProjectActivityForTicketsInput, ListTicketActivityInput, ListTicketActivityResponse, TicketAttemptMode, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput, } from "pstdio-api-contracts";
 import type { Ticket, Workspace } from "../resources";
 export type ListTicketsInput = {
     status?: string;

package/dist/api/workspaces.d.ts

@@ -1 +1 @@
-export type { CreateWorkspaceInput, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse, } from "pstdio-api-contracts";
+export type { CreateWorkspaceInput, ListWorkspaceActivityInput, ListWorkspaceActivityResponse, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse, } from "pstdio-api-contracts";

package/dist/client/client.d.ts

@@ -1,5 +1,6 @@
 import { type ActionClient } from "./actions";
 import { type AgentClient } from "./agents";
+import { type ExtensionClient } from "./extensions";
 import { type ProjectClient } from "./projects";
 import type { ClientOptions } from "./request";
 import { type SessionClient } from "./sessions";
@@ -20,5 +21,6 @@ export type PstdioClient = {
     skills: SkillClient;
     agents: AgentClient;
     actions: ActionClient;
+    extensions: ExtensionClient;
 };
 export declare const createClient: (options?: ClientOptions) => PstdioClient;

package/dist/client/extensions.d.ts

@@ -0,0 +1,7 @@
+import type { CommandExecuteRequest, CommandExecuteResponse, EnableInstalledExtensionRequest, EnableInstalledExtensionResponse } from "pstdio-api-contracts";
+import type { RequestFn } from "./request";
+export type ExtensionClient = {
+    enableInstalled(projectId: string, installName: string, request: EnableInstalledExtensionRequest): Promise<EnableInstalledExtensionResponse>;
+    execute(commandId: string, request: CommandExecuteRequest): Promise<CommandExecuteResponse>;
+};
+export declare const createExtensionClient: (request: RequestFn) => ExtensionClient;

package/dist/client/index.d.ts

@@ -1,6 +1,7 @@
 export type { ActionClient } from "./actions";
 export type { AgentClient } from "./agents";
 export { createClient, type PstdioClient } from "./client";
+export type { ExtensionClient } from "./extensions";
 export type { ProjectClient } from "./projects";
 export { type ClientOptions, createRequest, PstdioApiError, type RequestFn } from "./request";
 export type { SessionClient } from "./sessions";

package/dist/client/index.js

@@ -18,12 +18,44 @@ var createAgentClient = (request) => ({
   delete: (agentId) => request(`/v1/agents/${agentId}`, { method: "DELETE" })
 });
 
+// src/client/extensions.ts
+var createExtensionClient = (request) => ({
+  enableInstalled: (projectId, installName, body) => request(`/v1/projects/${projectId}/extensions/installed/${encodeURIComponent(installName)}/enable`, {
+    method: "POST",
+    body
+  }),
+  execute: (commandId, input) => {
+    const { projectId, ...body } = input;
+    return request(`/v1/projects/${projectId}/extensions/commands/${encodeURIComponent(commandId)}/execute`, {
+      method: "POST",
+      body
+    });
+  }
+});
+
 // src/client/projects.ts
 var createProjectClient = (request) => ({
   list: () => request("/v1/projects"),
   get: (projectId) => request(`/v1/projects/${projectId}`),
   create: (input) => request("/v1/projects", { method: "POST", body: input }),
   delete: (projectId) => request(`/v1/projects/${projectId}`, { method: "DELETE" }),
+  listActivity: (projectId, input = {}) => {
+    const params = new URLSearchParams;
+    if (input.resource_type)
+      params.append("resource_type", input.resource_type);
+    if (input.event_type)
+      params.append("event_type", input.event_type);
+    if (input.from)
+      params.append("from", input.from);
+    if (input.to)
+      params.append("to", input.to);
+    if (input.cursor)
+      params.append("cursor", input.cursor);
+    if (input.limit !== undefined)
+      params.append("limit", String(input.limit));
+    const query = params.toString();
+    return request(`/v1/projects/${projectId}/activity${query ? `?${query}` : ""}`);
+  },
   listPlugins: (projectId) => request(`/v1/projects/${projectId}/plugins`),
   registerPlugins: (projectId) => request(`/v1/projects/${projectId}/plugins/register`, { method: "POST" }),
   listRepos: (projectId) => request(`/v1/projects/${projectId}/repos`),
@@ -97,6 +129,21 @@ var createRequest = (options) => {
 
 // src/client/sessions.ts
 var createSessionClient = (request) => ({
+  listActivity: (sessionId, input = {}) => {
+    const params = new URLSearchParams;
+    if (input.event_type)
+      params.append("event_type", input.event_type);
+    if (input.from)
+      params.append("from", input.from);
+    if (input.to)
+      params.append("to", input.to);
+    if (input.cursor)
+      params.append("cursor", input.cursor);
+    if (input.limit !== undefined)
+      params.append("limit", String(input.limit));
+    const query = params.toString();
+    return request(`/v1/sessions/${sessionId}/activity${query ? `?${query}` : ""}`);
+  },
   list: (projectId) => request(`/v1/sessions?project_id=${projectId}`),
   get: (sessionId) => request(`/v1/sessions/${sessionId}`),
   create: (input) => request("/v1/sessions", { method: "POST", body: input }),
@@ -179,6 +226,22 @@ var buildTicketsQuery = (projectId, input = {}) => {
     params.append("search", input.search);
   return params.toString();
 };
+var buildActivityQuery = (input = {}) => {
+  const params = new URLSearchParams;
+  if (input.resource_type)
+    params.append("resource_type", input.resource_type);
+  if (input.event_type)
+    params.append("event_type", input.event_type);
+  if (input.from)
+    params.append("from", input.from);
+  if (input.to)
+    params.append("to", input.to);
+  if (input.cursor)
+    params.append("cursor", input.cursor);
+  if (input.limit !== undefined)
+    params.append("limit", String(input.limit));
+  return params.toString();
+};
 var createTicketClient = (request, options = {}) => ({
   list: (projectId, input) => request(`/v1/tickets?${buildTicketsQuery(projectId, input)}`),
   get: (ticketId) => request(`/v1/tickets/${ticketId}`),
@@ -186,6 +249,14 @@ var createTicketClient = (request, options = {}) => ({
   update: (ticketId, input) => request(`/v1/tickets/${ticketId}`, { method: "PATCH", body: input }),
   delete: (ticketId) => request(`/v1/tickets/${ticketId}`, { method: "DELETE" }),
   createAttempt: (ticketId, input) => request(`/v1/tickets/${ticketId}/attempts`, { method: "POST", body: input }),
+  listActivity: (ticketId, input) => {
+    const query = buildActivityQuery(input);
+    return request(`/v1/tickets/${ticketId}/activity${query ? `?${query}` : ""}`);
+  },
+  listProjectActivity: (projectId, input) => {
+    const query = buildActivityQuery(input);
+    return request(`/v1/projects/${projectId}/activity${query ? `?${query}` : ""}`);
+  },
   updateWhenAttemptStatus: (ticketId, input) => request(`/v1/tickets/${ticketId}/update-when-attempt-status`, { method: "POST", body: input }),
   listFiles: (ticketId) => request(`/v1/tickets/${ticketId}/files`),
   getFileContent: async (ticketId, fileId) => {
@@ -206,6 +277,21 @@ var createTicketClient = (request, options = {}) => ({
 
 // src/client/workspaces.ts
 var createWorkspaceClient = (request) => ({
+  listActivity: (workspaceId, input = {}) => {
+    const params = new URLSearchParams;
+    if (input.event_type)
+      params.append("event_type", input.event_type);
+    if (input.from)
+      params.append("from", input.from);
+    if (input.to)
+      params.append("to", input.to);
+    if (input.cursor)
+      params.append("cursor", input.cursor);
+    if (input.limit !== undefined)
+      params.append("limit", String(input.limit));
+    const query = params.toString();
+    return request(`/v1/workspaces/${workspaceId}/activity${query ? `?${query}` : ""}`);
+  },
   list: (projectId) => request(`/v1/workspaces?project_id=${projectId}`),
   getByShorthand: (projectId, shorthand) => request(`/v1/workspaces/by-shorthand?project_id=${encodeURIComponent(projectId)}&shorthand=${encodeURIComponent(shorthand)}`),
   create: (input) => request("/v1/workspaces", { method: "POST", body: input }),
@@ -227,7 +313,8 @@ var createClient = (options = {}) => {
     templates: createTemplateClient(request),
     skills: createSkillClient(request),
     agents: createAgentClient(request),
-    actions: createActionClient(request)
+    actions: createActionClient(request),
+    extensions: createExtensionClient(request)
   };
 };
 export {

package/dist/client/projects.d.ts

@@ -1,4 +1,4 @@
-import type { CreateProjectInput, RegisterRepoInput, Repo } from "pstdio-api-contracts";
+import type { CreateProjectInput, ListProjectActivityForTicketsInput, ListTicketActivityResponse, RegisterRepoInput, Repo } from "pstdio-api-contracts";
 import type { Project } from "../resources";
 import type { RequestFn } from "./request";
 type RegisteredPlugin = {
@@ -16,6 +16,7 @@ export type ProjectClient = {
     delete(projectId: string): Promise<void>;
     listPlugins(projectId: string): Promise<RegisteredPluginsResponse>;
     registerPlugins(projectId: string): Promise<RegisteredPluginsResponse>;
+    listActivity(projectId: string, input?: ListProjectActivityForTicketsInput): Promise<ListTicketActivityResponse>;
     listRepos(projectId: string): Promise<Repo[]>;
     registerRepo(projectId: string, input: RegisterRepoInput): Promise<Repo>;
     removeRepo(projectId: string, repoId: string): Promise<void>;

package/dist/client/sessions.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalInput, CreateSessionInput, FollowUpInput, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse } from "pstdio-api-contracts";
+import type { ApprovalInput, CreateSessionInput, FollowUpInput, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse } from "pstdio-api-contracts";
 import type { Session } from "../resources";
 import type { RequestFn } from "./request";
 export type SessionClient = {
@@ -11,5 +11,6 @@ export type SessionClient = {
     getConversation(sessionId: string): Promise<SessionConversationResponse>;
     resolveSessionId(input: ResolveSessionIdInput): Promise<ResolveSessionIdResponse>;
     updateStatus(sessionId: string, status: string): Promise<Session>;
+    listActivity(sessionId: string, input?: ListSessionActivityInput): Promise<ListSessionActivityResponse>;
 };
 export declare const createSessionClient: (request: RequestFn) => SessionClient;

package/dist/client/tickets.d.ts

@@ -1,4 +1,4 @@
-import type { CreateTicketAttemptInput, CreateTicketInput, ListTicketsInput, TicketAttemptResponse, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput } from "../api/tickets";
+import type { CreateTicketAttemptInput, CreateTicketInput, ListProjectActivityForTicketsInput, ListTicketActivityInput, ListTicketActivityResponse, ListTicketsInput, TicketAttemptResponse, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput } from "../api/tickets";
 import type { Ticket, TicketDetail, TicketFile, TicketListItem } from "../resources";
 import { type ClientOptions, type RequestFn } from "./request";
 export type TicketClient = {
@@ -8,6 +8,8 @@ export type TicketClient = {
     update(ticketId: string, input: UpdateTicketInput): Promise<Ticket>;
     delete(ticketId: string): Promise<void>;
     createAttempt(ticketId: string, input: CreateTicketAttemptInput): Promise<TicketAttemptResponse>;
+    listActivity(ticketId: string, input?: ListTicketActivityInput): Promise<ListTicketActivityResponse>;
+    listProjectActivity(projectId: string, input?: ListProjectActivityForTicketsInput): Promise<ListTicketActivityResponse>;
     updateWhenAttemptStatus(ticketId: string, input: UpdateWhenAttemptStatusInput): Promise<UpdateWhenAttemptStatusResponse>;
     listFiles(ticketId: string): Promise<TicketFile[]>;
     getFileContent(ticketId: string, fileId: string): Promise<Uint8Array>;

package/dist/client/workspaces.d.ts

@@ -1,4 +1,4 @@
-import type { CreateWorkspaceInput, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse } from "pstdio-api-contracts";
+import type { CreateWorkspaceInput, ListWorkspaceActivityInput, ListWorkspaceActivityResponse, RemoveWorktreeResponse, UpdateAttemptStatusInput, UpdateAttemptStatusResponse } from "pstdio-api-contracts";
 import type { Workspace, WorkspaceListItem } from "../resources";
 import type { RequestFn } from "./request";
 export type WorkspaceClient = {
@@ -6,6 +6,7 @@ export type WorkspaceClient = {
     getByShorthand(projectId: string, shorthand: string): Promise<Workspace>;
     create(input: CreateWorkspaceInput): Promise<Workspace>;
     updateAttemptStatus(workspaceId: string, input: UpdateAttemptStatusInput): Promise<UpdateAttemptStatusResponse>;
+    listActivity(workspaceId: string, input?: ListWorkspaceActivityInput): Promise<ListWorkspaceActivityResponse>;
     removeWorktree(workspaceId: string): Promise<RemoveWorktreeResponse>;
     delete(workspaceId: string): Promise<void>;
 };

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

@@ -0,0 +1,28 @@
+import type { CommandDefinition, HookDefinition, MiddlewareDefinition } from "./types/extension";
+import type { Struct } from "./types/json";
+import type { ParamObjectSchema } from "./types/params";
+/**
+ * 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() },
+ *     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.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionDefinition } from "./types/extension";
+/**
+ * Identity helper that preserves the literal type of the passed extension. Authors get
+ * full autocomplete on contributions, and `commandsOf(ext)` can derive typed refs from
+ * the returned definition.
+ *
+ * @example
+ *   export default defineExtension({
+ *     id: "pstdio.example",
+ *     namespace: "example",
+ *     name: "Example",
+ *     apiVersion: "1",
+ *     commands: { ... },
+ *   });
+ */
+export declare const defineExtension: <const TExtension extends ExtensionDefinition>(extension: TExtension) => TExtension;

package/dist/extensions/index.d.ts

@@ -0,0 +1,8 @@
+export { defineCommand, defineHook, defineMiddleware } from "./define-command";
+export { defineExtension } from "./define-extension";
+export { projectEvents, projectSlots, sessionEvents, sessionSlots, workspaceEvents, workspaceSlots, } from "./kernel-slots";
+export { packageAsset } from "./package-asset";
+export { params } from "./params";
+export { commandEvent, commandRef, commandsOf, eventRef } from "./refs";
+export { defineSlot } from "./slots";
+export type * from "./types";

package/dist/extensions/index.js

@@ -0,0 +1,111 @@
+// src/extensions/define-command.ts
+var defineCommand = (definition) => definition;
+var defineMiddleware = (definition) => definition;
+var defineHook = (definition) => definition;
+// src/extensions/define-extension.ts
+var defineExtension = (extension) => extension;
+// src/extensions/refs.ts
+var commandRef = (id) => ({ id });
+var eventRef = (id) => ({ id });
+var commandEvent = (command, phase) => ({
+  id: `command.${phase}:${command.id}`
+});
+var commandsOf = (extension) => {
+  const refs = {};
+  const commands = extension.commands ?? {};
+  for (const key of Object.keys(commands)) {
+    refs[key] = { id: `${extension.namespace}.${key}` };
+  }
+  return refs;
+};
+
+// src/extensions/slots.ts
+var defineSlot = (id, options) => ({
+  id,
+  kind: options.kind,
+  label: options.label,
+  description: options.description,
+  metadata: options.metadata
+});
+
+// src/extensions/kernel-slots.ts
+var projectSlots = {
+  sidebarNav: defineSlot("project.sidebarNav", { kind: "navigation" }),
+  sidebar: defineSlot("project.sidebar", { kind: "view" }),
+  headerPrimary: defineSlot("project.headerPrimary", { kind: "menu" }),
+  headerOverflow: defineSlot("project.headerOverflow", { kind: "menu" }),
+  settingsPanels: defineSlot("project.settingsPanels", { kind: "settings" })
+};
+var sessionSlots = {
+  headerPrimary: defineSlot("session.headerPrimary", { kind: "menu" }),
+  headerOverflow: defineSlot("session.headerOverflow", { kind: "menu" }),
+  transcriptActions: defineSlot("session.transcriptActions", { kind: "menu" })
+};
+var workspaceSlots = {
+  headerPrimary: defineSlot("workspace.headerPrimary", { kind: "menu" }),
+  headerOverflow: defineSlot("workspace.headerOverflow", { kind: "menu" }),
+  tabs: defineSlot("workspace.tabs", { kind: "navigation" }),
+  sidebar: defineSlot("workspace.sidebar", { kind: "view" })
+};
+var projectEvents = {
+  opened: eventRef("project.opened")
+};
+var sessionEvents = {
+  started: eventRef("session.started"),
+  completed: eventRef("session.completed")
+};
+var workspaceEvents = {
+  created: eventRef("workspace.created"),
+  archived: eventRef("workspace.archived"),
+  deleted: eventRef("workspace.deleted")
+};
+// src/extensions/package-asset.ts
+var packageAsset = (path, baseUrl) => ({
+  kind: "package-asset",
+  path,
+  baseUrl
+});
+// src/extensions/params.ts
+var params = {
+  text: (options = {}) => ({ type: "text", ...options }),
+  longText: (options = {}) => ({ type: "longtext", ...options }),
+  number: (options = {}) => ({ type: "number", ...options }),
+  boolean: (options = {}) => ({ type: "boolean", ...options }),
+  select: (options) => ({ type: "select", ...options }),
+  multiSelect: (options) => ({
+    type: "multi-select",
+    ...options
+  }),
+  repo: (options = {}) => ({ type: "repo", ...options }),
+  harness: (options = {}) => ({ type: "harness", ...options }),
+  template: (options) => ({
+    label: options.label,
+    description: options.description,
+    required: options.required,
+    defaultValue: options.defaultValue,
+    metadata: options.metadata,
+    type: "template",
+    templateType: options.type
+  }),
+  resource: (options) => ({ type: "resource", ...options }),
+  json: (options = {}) => ({ type: "json", ...options })
+};
+export {
+  workspaceSlots,
+  workspaceEvents,
+  sessionSlots,
+  sessionEvents,
+  projectSlots,
+  projectEvents,
+  params,
+  packageAsset,
+  eventRef,
+  defineSlot,
+  defineMiddleware,
+  defineHook,
+  defineExtension,
+  defineCommand,
+  commandsOf,
+  commandRef,
+  commandEvent
+};

package/dist/extensions/kernel-slots.d.ts

@@ -0,0 +1,46 @@
+import type { JsonObject } from "./types/json";
+import type { ResourceAnchor } from "./types/resources";
+export declare const projectSlots: {
+    sidebarNav: import("./types").SlotRef<object, "navigation">;
+    sidebar: import("./types").SlotRef<object, "view">;
+    headerPrimary: import("./types").SlotRef<object, "menu">;
+    headerOverflow: import("./types").SlotRef<object, "menu">;
+    settingsPanels: import("./types").SlotRef<object, "settings">;
+};
+export declare const sessionSlots: {
+    headerPrimary: import("./types").SlotRef<object, "menu">;
+    headerOverflow: import("./types").SlotRef<object, "menu">;
+    transcriptActions: import("./types").SlotRef<object, "menu">;
+};
+export declare const workspaceSlots: {
+    headerPrimary: import("./types").SlotRef<object, "menu">;
+    headerOverflow: import("./types").SlotRef<object, "menu">;
+    tabs: import("./types").SlotRef<object, "navigation">;
+    sidebar: import("./types").SlotRef<object, "view">;
+};
+export declare const projectEvents: {
+    opened: import("./types").EventRef<{
+        projectId: string;
+    }>;
+};
+export declare const sessionEvents: {
+    started: import("./types").EventRef<{
+        sessionId: string;
+        anchors?: ResourceAnchor[];
+    }>;
+    completed: import("./types").EventRef<{
+        sessionId: string;
+        anchors?: ResourceAnchor[];
+    }>;
+};
+export declare const workspaceEvents: {
+    created: import("./types").EventRef<{
+        workspace: JsonObject;
+    }>;
+    archived: import("./types").EventRef<{
+        workspace: JsonObject;
+    }>;
+    deleted: import("./types").EventRef<{
+        workspace: JsonObject;
+    }>;
+};

package/dist/extensions/package-asset.d.ts

@@ -0,0 +1,10 @@
+import type { PackageAssetDescriptor } from "./types/resources";
+/**
+ * Reference an asset shipped alongside the extension's compiled output. `path` is
+ * resolved relative to `baseUrl`; in practice authors always pass `import.meta.url`
+ * so the runtime can locate the file no matter where the extension is installed.
+ *
+ * @example
+ *   webview: { entry: packageAsset("./dist/page.html", import.meta.url) }
+ */
+export declare const packageAsset: (path: string, baseUrl: string) => PackageAssetDescriptor;

package/dist/extensions/params.d.ts

@@ -0,0 +1,26 @@
+import type { BooleanParam, HarnessParam, JsonParam, LongTextParam, MultiSelectParam, NumberParam, RepoParam, ResourceParam, SelectParam, TemplateParam, TextParam } from "./types/params";
+/**
+ * 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: (options?: Omit<TextParam, "type">) => TextParam;
+    longText: (options?: Omit<LongTextParam, "type">) => LongTextParam;
+    number: (options?: Omit<NumberParam, "type">) => NumberParam;
+    boolean: (options?: Omit<BooleanParam, "type">) => BooleanParam;
+    select: (options: Omit<SelectParam, "type">) => SelectParam;
+    multiSelect: (options: Omit<MultiSelectParam, "type">) => MultiSelectParam;
+    repo: (options?: Omit<RepoParam, "type">) => RepoParam;
+    harness: (options?: Omit<HarnessParam, "type">) => HarnessParam;
+    template: (options: Omit<TemplateParam, "type" | "templateType"> & {
+        type: string;
+    }) => TemplateParam;
+    resource: (options: Omit<ResourceParam, "type">) => ResourceParam;
+    json: <T = unknown>(options?: Omit<JsonParam<T>, "type">) => JsonParam<T>;
+};

package/dist/extensions/refs.d.ts

@@ -0,0 +1,38 @@
+import type { CommandLifecycleEventPayload, CommandLifecyclePhase, CommandRef } from "./types/commands";
+import type { EventRef } from "./types/events";
+import type { CommandDefinition } from "./types/extension";
+import type { Struct } from "./types/json";
+import type { ParamObjectSchema, ParamsOf } from "./types/params";
+/**
+ * Build a typed reference to a command by id. Authors generally prefer `commandsOf(ext)`,
+ * which derives refs from the extension definition so a renamed command becomes a type
+ * error at every call site.
+ */
+export declare const commandRef: <TParams extends Struct = Struct, TResult = unknown>(id: string) => CommandRef<TParams, TResult>;
+/** Build a typed reference to an event by id. */
+export declare const eventRef: <TPayload extends Struct = Struct>(id: string) => EventRef<TPayload>;
+/**
+ * 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>>;
+type CommandsRecord = Record<string, CommandDefinition<any, any>>;
+type CommandRefFromDefinition<TDefinition> = TDefinition extends CommandDefinition<infer TSchema, infer TResult> ? CommandRef<TSchema extends ParamObjectSchema ? ParamsOf<TSchema> : Struct, TResult> : never;
+type CommandsRefMap<TCommands extends CommandsRecord> = {
+    [K in keyof TCommands]: CommandRefFromDefinition<TCommands[K]>;
+};
+/**
+ * Derive typed `CommandRef`s from an extension. Renaming a command in the definition
+ * surfaces as a type error wherever the ref is used.
+ *
+ * @example
+ *   const ext = defineExtension({ id: "lab", namespace: "lab", commands: { ... } });
+ *   const labCommands = commandsOf(ext);
+ *   labCommands.awaken; // CommandRef<{ title: string }, ...>
+ */
+export declare const commandsOf: <TExtension extends {
+    namespace: string;
+    commands?: CommandsRecord;
+}>(extension: TExtension) => CommandsRefMap<NonNullable<TExtension["commands"]>>;
+export {};

package/dist/extensions/slots.d.ts

@@ -0,0 +1,14 @@
+import type { Struct } from "./types/json";
+import type { SlotOptions, SlotRef, UiSlotKind } from "./types/slots";
+/**
+ * Define a UI slot that contributions can target. The `TContext` parameter constrains
+ * the data passed to renderers/menus invoked through the slot, and `TKind` picks the
+ * contribution shape (`menu`, `navigation`, `view`, `settings`, `renderer`).
+ *
+ * @example
+ *   export const projectHeader = defineSlot<{ projectId: string }, "menu">("project.header", {
+ *     kind: "menu",
+ *     label: "Project header",
+ *   });
+ */
+export declare const defineSlot: <TContext extends Struct = Struct, TKind extends UiSlotKind = UiSlotKind>(id: string, options: SlotOptions<TKind>) => SlotRef<TContext, TKind>;