@pstdio/sdk 0.7.0 → 0.9.0

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

@@ -1,15 +1,58 @@
-import type { ExtensionDefinition } from "./types/extension";
-type ExactExtensionDefinition<TExtension extends ExtensionDefinition> = TExtension & Record<Exclude<keyof TExtension, keyof ExtensionDefinition>, never>;
+import type { ExtensionSettingProperty, ExtensionSettingsContribution } from "./types/contributions";
+import type { CommandDefinition, ExtensionDefinition, HookDefinition, MiddlewareDefinition, ScheduleContribution } from "./types/extension";
+import type { Struct } from "./types/json";
+import type { ParamObjectSchema } from "./types/params";
+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;
+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 preserves the literal type of the passed contributions. Authors
- * get full autocomplete on contributions, and `commandsOf(packageName, ext)` can derive typed refs
- * from the returned definition. Extension identity (id, name, version, description,
- * publisher, engines.pstdio) lives in package.json.
+ * Identity helper that types the passed contributions. Authors get autocomplete on
+ * contributions, and `commandsOf(packageName, ext)` can derive typed refs from the
+ * returned definition. Extension identity (id, name, version, description, publisher,
+ * engines.pstdio) lives in package.json.
  *
  * @example
  *   export default defineExtension({
  *     commands: { ... },
  *   });
  */
-export declare const defineExtension: <const TExtension extends ExtensionDefinition>(extension: ExactExtensionDefinition<TExtension>) => TExtension;
+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,11 +1,12 @@
 export { defineCommand, defineHook, defineMiddleware } from "./define-command";
 export { defineExtension } from "./define-extension";
 export { defineExtensionView, type ExtensionViewModule, type ExtensionViewRender, type ExtensionViewRenderContext, type GuestHost, type PropsStore, } from "./define-extension-view";
-export { projectEvents, projectSlots, sessionEvents, sessionSlots, workspaceEvents, workspaceSlots, } from "./kernel-slots";
+export type { AttemptStatusChangePayload, CommitPayload, ConflictPayload, MergePayload, RebasePayload, SessionLifecyclePayload, TicketArchivedEventPayload, TicketLifecyclePayload, TicketStatusChangePayload, WorktreeCreatedEventPayload, WorktreeRemovedPayload, } from "./kernel-slots";
+export { attemptStatusEvents, gitEvents, projectEvents, projectSlots, sessionEvents, sessionSlots, ticketEvents, ticketSlots, workspaceCommands, workspaceEvents, workspaceSlots, worktreeEvents, } 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";
 export { EXTENSION_API_VERSION } from "./types/extension";
 export { ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES, WEBVIEW_DECLARABLE_CAPABILITIES, WEBVIEW_HOST_CAPABILITIES, WEBVIEW_HOST_CAPABILITY_VERSION, } from "./types/webview-capabilities";
+export { getWorkbenchTargetDefinition, type WorkbenchAttachmentTarget, type WorkbenchContributionKind, type WorkbenchLayoutTarget, type WorkbenchMenuTarget, type WorkbenchModeLayoutTarget, type WorkbenchSettingsScope, type WorkbenchSettingsTarget, type WorkbenchTargetDefinition, type WorkbenchTargetGranularity, type WorkbenchTreeTarget, type WorkbenchViewTarget, workbenchMenuTargets, workbenchModeLayoutTargets, workbenchSettingsScopes, workbenchSettingsTargets, workbenchTargets, workbenchTreeTargets, workbenchViewTargets, } from "./workbench-targets";

package/dist/extensions/index.js

@@ -37,7 +37,6 @@ var defineSlot = (id, options) => ({
 
 // 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" }),
@@ -49,10 +48,13 @@ var sessionSlots = {
   headerOverflow: defineSlot("session.headerOverflow", { kind: "menu" }),
   transcriptActions: defineSlot("session.transcriptActions", { kind: "menu" })
 };
+var ticketSlots = {
+  headerPrimary: defineSlot("ticket.headerPrimary", { kind: "menu" }),
+  headerOverflow: defineSlot("ticket.headerOverflow", { 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 = {
@@ -60,13 +62,39 @@ var projectEvents = {
 };
 var sessionEvents = {
   started: eventRef("session.started"),
+  resumed: eventRef("session.resumed"),
+  awaitingInput: eventRef("session.awaitingInput"),
+  succeeded: eventRef("session.succeeded"),
+  failed: eventRef("session.failed"),
   completed: eventRef("session.completed")
 };
+var ticketEvents = {
+  created: eventRef("ticket.created"),
+  statusChanged: eventRef("ticket.statusChanged"),
+  archived: eventRef("ticket.archived"),
+  deleted: eventRef("ticket.deleted")
+};
 var workspaceEvents = {
   created: eventRef("workspace.created"),
   archived: eventRef("workspace.archived"),
   deleted: eventRef("workspace.deleted")
 };
+var worktreeEvents = {
+  created: eventRef("worktree.created"),
+  removed: eventRef("worktree.removed")
+};
+var gitEvents = {
+  committed: eventRef("git.committed"),
+  rebased: eventRef("git.rebased"),
+  merged: eventRef("git.merged"),
+  conflicted: eventRef("git.conflicted")
+};
+var attemptStatusEvents = {
+  changed: eventRef("attemptStatus.changed")
+};
+var workspaceCommands = {
+  setAttemptStatus: commandRef("kernel.workspace.setAttemptStatus")
+};
 // src/extensions/package-asset.ts
 var packageAsset = (path, baseUrl) => ({
   kind: "package-asset",
@@ -75,17 +103,17 @@ var packageAsset = (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 }),
+  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 }),
+  repo: (options) => ({ type: "repo", ...options }),
+  harness: (options) => ({ type: "harness", ...options }),
   template: (options) => ({
     label: options.label,
     description: options.description,
@@ -96,7 +124,7 @@ var params = {
     templateType: options.type
   }),
   resource: (options) => ({ type: "resource", ...options }),
-  json: (options = {}) => ({ type: "json", ...options })
+  json: (options) => ({ type: "json", ...options })
 };
 // src/extensions/types/extension.ts
 var EXTENSION_API_VERSION = "1.0.0";
@@ -107,24 +135,135 @@ var WEBVIEW_DECLARABLE_CAPABILITIES = [
   "resource.open",
   "notification.show",
   "preferences.get",
-  "preferences.set"
+  "preferences.set",
+  "extension.settings.all",
+  "extension.settings.get",
+  "extension.settings.set",
+  "extension.settings.delete"
 ];
 var ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES = ["host.dispatchKeyboardEvent"];
 var WEBVIEW_HOST_CAPABILITIES = [
   ...WEBVIEW_DECLARABLE_CAPABILITIES,
   ...ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES
 ];
+// src/extensions/workbench-targets.ts
+var workbenchMenuTargets = [
+  "workbench.top.actions",
+  "workbench.top.overflow",
+  "workbench.commandPalette"
+];
+var workbenchTreeTargets = [
+  "workbench.left.tree",
+  "workbench.main.left.tree",
+  "workbench.main.right.tree"
+];
+var workbenchViewTargets = [
+  "workbench.main",
+  "workbench.main.left",
+  "workbench.main.right",
+  "workbench.main.bottom"
+];
+var workbenchSettingsTargets = ["workbench.settings"];
+var workbenchSettingsScopes = ["project", "global"];
+var workbenchModeLayoutTargets = [
+  "workbench.left",
+  "workbench.main.left",
+  "workbench.main",
+  "workbench.main.right",
+  "workbench.main.bottom"
+];
+var workbenchTargets = [
+  {
+    id: "workbench.top.actions",
+    allowedKinds: ["menu"],
+    granularity: "surface",
+    rationale: "Primary command surface in the host-owned top workbench chrome."
+  },
+  {
+    id: "workbench.top.overflow",
+    allowedKinds: ["menu"],
+    granularity: "surface",
+    rationale: "Secondary command surface in the host-owned top workbench chrome."
+  },
+  {
+    id: "workbench.commandPalette",
+    allowedKinds: ["menu"],
+    granularity: "surface",
+    rationale: "Global command discovery surface owned by the workbench."
+  },
+  {
+    id: "workbench.left.tree",
+    allowedKinds: ["treeItem"],
+    granularity: "areaTree",
+    rationale: "Tree entries for the active tree renderer mounted in the left area."
+  },
+  {
+    id: "workbench.main.left.tree",
+    allowedKinds: ["treeItem"],
+    granularity: "areaTree",
+    rationale: "Tree entries for the active tree renderer mounted in the main-left area."
+  },
+  {
+    id: "workbench.main.right.tree",
+    allowedKinds: ["treeItem"],
+    granularity: "areaTree",
+    rationale: "Tree entries for the active tree renderer mounted in the main-right area."
+  },
+  {
+    id: "workbench.main",
+    allowedKinds: ["view"],
+    granularity: "area",
+    rationale: "Direct extension view placement in the main area."
+  },
+  {
+    id: "workbench.main.left",
+    allowedKinds: ["view"],
+    granularity: "area",
+    rationale: "Direct extension view placement in the main-left area."
+  },
+  {
+    id: "workbench.main.right",
+    allowedKinds: ["view"],
+    granularity: "area",
+    rationale: "Direct extension view placement in the main-right area."
+  },
+  {
+    id: "workbench.main.bottom",
+    allowedKinds: ["view"],
+    granularity: "area",
+    rationale: "Direct extension view placement in the main-bottom area."
+  },
+  {
+    id: "workbench.settings",
+    allowedKinds: ["settings"],
+    granularity: "surface",
+    rationale: "Settings panel placement in host-owned settings navigation."
+  }
+];
+var getWorkbenchTargetDefinition = (id) => workbenchTargets.find((target) => target.id === id);
 export {
+  worktreeEvents,
   workspaceSlots,
   workspaceEvents,
+  workspaceCommands,
+  workbenchViewTargets,
+  workbenchTreeTargets,
+  workbenchTargets,
+  workbenchSettingsTargets,
+  workbenchSettingsScopes,
+  workbenchModeLayoutTargets,
+  workbenchMenuTargets,
+  ticketSlots,
+  ticketEvents,
   sessionSlots,
   sessionEvents,
   projectSlots,
   projectEvents,
   params,
   packageAsset,
+  gitEvents,
+  getWorkbenchTargetDefinition,
   eventRef,
-  defineSlot,
   defineMiddleware,
   defineHook,
   defineExtensionView,
@@ -133,6 +272,7 @@ export {
   commandsOf,
   commandRef,
   commandEvent,
+  attemptStatusEvents,
   WEBVIEW_HOST_CAPABILITY_VERSION,
   WEBVIEW_HOST_CAPABILITIES,
   WEBVIEW_DECLARABLE_CAPABILITIES,

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

@@ -1,7 +1,98 @@
-import type { JsonObject } from "./types/json";
+import type { ExtensionTicket, ExtensionWorkspace, SetAttemptStatusInput, SetAttemptStatusResult } from "./types/context";
 import type { ResourceAnchor } from "./types/resources";
+/** @deprecated Legacy core ticket event payload. Ticket events are owned by the pstdio tickets extension. */
+export interface TicketArchivedEventPayload {
+    projectId: string;
+    ticket: ExtensionTicket;
+}
+export interface WorktreeCreatedEventPayload {
+    projectId: string;
+    repoPath: string;
+    worktreePath: string;
+    branch: string;
+    workspace: string;
+    workspaceId: string;
+    /** @deprecated Legacy ticket worktree linkage. Ticket worktree setup is owned by the pstdio tickets extension. */
+    ticket: string;
+}
+/** @deprecated Legacy core ticket event payload. Ticket events are owned by the pstdio tickets extension. */
+export interface TicketLifecyclePayload {
+    projectId: string;
+    ticket: ExtensionTicket;
+}
+/** @deprecated Legacy core ticket event payload. Ticket events are owned by the pstdio tickets extension. */
+export interface TicketStatusChangePayload {
+    projectId: string;
+    ticket: ExtensionTicket;
+    fromStatus: string | null;
+    toStatus: string | null;
+}
+export interface AttemptStatusChangePayload {
+    projectId: string;
+    workspaceId: string;
+    /** @deprecated Legacy ticket attempt linkage. Ticket data is owned by the pstdio tickets extension. */
+    ticket: ExtensionTicket | null;
+    fromStatus: string | null;
+    toStatus: string;
+    statusChangeId?: string;
+    sessionId: string | null;
+    originalSessionId: string | null;
+    worktreePath: string | null;
+    workspace: ExtensionWorkspace;
+}
+export interface SessionLifecyclePayload {
+    projectId: string;
+    sessionId: string;
+    sessionStatus?: string;
+    originalSessionId?: string;
+    workspace?: ExtensionWorkspace;
+    workspaceId?: string;
+    worktreePath?: string;
+    branch?: string;
+    /** @deprecated Legacy ticket session linkage. Ticket data is owned by the pstdio tickets extension. */
+    ticket?: ExtensionTicket;
+    attemptStatus?: string;
+}
+export interface WorktreeRemovedPayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath: string;
+    workspace?: ExtensionWorkspace;
+    workspaceId?: string;
+    /** @deprecated Legacy ticket worktree linkage. Ticket data is owned by the pstdio tickets extension. */
+    ticket?: ExtensionTicket | string;
+}
+export interface CommitPayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    commitSha?: string;
+    workspace?: ExtensionWorkspace;
+    /** @deprecated Legacy ticket git linkage. Ticket data is owned by the pstdio tickets extension. */
+    ticket?: ExtensionTicket | string;
+}
+export interface RebasePayload {
+    projectId: string;
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    workspace?: ExtensionWorkspace;
+    ticket?: ExtensionTicket | string;
+}
+export interface MergePayload extends CommitPayload {
+}
+export interface ConflictPayload {
+    projectId: string;
+    operation: "rebase" | "merge";
+    repoPath?: string;
+    worktreePath?: string;
+    branch?: string;
+    workspace?: ExtensionWorkspace;
+    /** @deprecated Legacy ticket git linkage. Ticket data is owned by the pstdio tickets extension. */
+    ticket?: ExtensionTicket | string;
+}
 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">;
@@ -13,10 +104,14 @@ export declare const sessionSlots: {
     headerOverflow: import("./types").SlotRef<object, "menu">;
     transcriptActions: import("./types").SlotRef<object, "menu">;
 };
+/** @deprecated Legacy core ticket slots. Ticket UI contributions are owned by the pstdio tickets extension. */
+export declare const ticketSlots: {
+    headerPrimary: import("./types").SlotRef<object, "menu">;
+    headerOverflow: 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: {
@@ -25,23 +120,49 @@ export declare const projectEvents: {
     }>;
 };
 export declare const sessionEvents: {
-    started: import("./types").EventRef<{
-        sessionId: string;
+    started: import("./types").EventRef<SessionLifecyclePayload & {
         anchors?: ResourceAnchor[];
     }>;
-    completed: import("./types").EventRef<{
-        sessionId: string;
+    resumed: import("./types").EventRef<SessionLifecyclePayload>;
+    awaitingInput: import("./types").EventRef<SessionLifecyclePayload>;
+    succeeded: import("./types").EventRef<SessionLifecyclePayload>;
+    failed: import("./types").EventRef<SessionLifecyclePayload>;
+    completed: import("./types").EventRef<SessionLifecyclePayload & {
         anchors?: ResourceAnchor[];
     }>;
 };
+/** @deprecated Legacy core ticket events. Ticket events are owned by the pstdio tickets extension. */
+export declare const ticketEvents: {
+    created: import("./types").EventRef<TicketLifecyclePayload>;
+    statusChanged: import("./types").EventRef<TicketStatusChangePayload>;
+    archived: import("./types").EventRef<TicketArchivedEventPayload>;
+    deleted: import("./types").EventRef<TicketLifecyclePayload>;
+};
 export declare const workspaceEvents: {
     created: import("./types").EventRef<{
-        workspace: JsonObject;
+        workspace: ExtensionWorkspace;
     }>;
     archived: import("./types").EventRef<{
-        workspace: JsonObject;
+        workspace: ExtensionWorkspace;
     }>;
     deleted: import("./types").EventRef<{
-        workspace: JsonObject;
+        workspace: ExtensionWorkspace;
     }>;
 };
+export declare const worktreeEvents: {
+    created: import("./types").EventRef<WorktreeCreatedEventPayload>;
+    removed: import("./types").EventRef<WorktreeRemovedPayload>;
+};
+export declare const gitEvents: {
+    committed: import("./types").EventRef<CommitPayload>;
+    rebased: import("./types").EventRef<RebasePayload>;
+    merged: import("./types").EventRef<MergePayload>;
+    conflicted: import("./types").EventRef<ConflictPayload>;
+};
+/** @deprecated Legacy ticket attempt status events. Workspace status automation is extension-owned. */
+export declare const attemptStatusEvents: {
+    changed: import("./types").EventRef<AttemptStatusChangePayload>;
+};
+export declare const workspaceCommands: {
+    setAttemptStatus: import("./types").CommandRef<SetAttemptStatusInput, SetAttemptStatusResult>;
+};

package/dist/extensions/params.d.ts

@@ -1,4 +1,10 @@
 import type { BooleanParam, HarnessParam, JsonParam, LongTextParam, MultiSelectParam, NumberParam, RepoParam, ResourceParam, SelectParam, TemplateParam, TextParam } from "./types/params";
+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.
@@ -10,17 +16,18 @@ import type { BooleanParam, HarnessParam, JsonParam, LongTextParam, MultiSelectP
  *   }
  */
 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"> & {
+    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>>;
+    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;
-    }) => TemplateParam;
-    resource: (options: Omit<ResourceParam, "type">) => ResourceParam;
-    json: <T = unknown>(options?: Omit<JsonParam<T>, "type">) => JsonParam<T>;
+    }>(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>>;
 };
+export {};

package/dist/extensions/refs.d.ts

@@ -17,8 +17,8 @@ export declare const eventRef: <TPayload extends Struct = Struct>(id: string) =>
  * 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 CommandsRecord = Record<string, CommandDefinition<any, any, any>>;
+type CommandRefFromDefinition<TDefinition> = TDefinition extends CommandDefinition<infer TSchema, infer TResult, infer _TSettings> ? CommandRef<TSchema extends ParamObjectSchema ? ParamsOf<TSchema> : Struct, TResult> : never;
 type CommandsRefMap<TCommands extends CommandsRecord> = {
     [K in keyof TCommands]: CommandRefFromDefinition<TCommands[K]>;
 };
@@ -32,7 +32,7 @@ type CommandsRefMap<TCommands extends CommandsRecord> = {
  * @example
  *   const ext = defineExtension({ commands: { ... } });
  *   const labCommands = commandsOf("extension-lab", ext);
- *   labCommands.awaken; // CommandRef<{ title: string }, ...>
+ *   labCommands.awaken; // CommandRef<{ title?: string }, ...>
  */
 export declare const commandsOf: <TExtension extends {
     commands?: CommandsRecord;

package/dist/extensions/slots.d.ts

@@ -1,14 +1,6 @@
 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",
- *   });
+ * Define a host-owned UI slot that extension contributions can target.
  */
 export declare const defineSlot: <TContext extends Struct = Struct, TKind extends UiSlotKind = UiSlotKind>(id: string, options: SlotOptions<TKind>) => SlotRef<TContext, TKind>;

package/dist/extensions/types/commands.d.ts

@@ -1,3 +1,4 @@
+import type { WorkbenchAttachmentTarget } from "../workbench-targets";
 import type { JsonObject, JsonValue, Struct } from "./json";
 import type { RepoContext, ResourceRef } from "./resources";
 import type { SlotInvocationContext } from "./slots";
@@ -13,11 +14,18 @@ export interface SerializedError {
     stack?: string;
     cause?: JsonValue;
 }
+export interface WorkbenchAttachmentInvocationContext {
+    target: WorkbenchAttachmentTarget;
+    mode?: string;
+    projectId?: string;
+    resource?: ResourceRef;
+}
 export interface CommandInvocation<TParams extends Struct = Struct> {
     params: TParams;
     resource?: ResourceRef;
     repoId?: string;
     repoPath?: string;
+    attachment?: WorkbenchAttachmentInvocationContext;
     slot?: SlotInvocationContext;
     metadata?: JsonObject;
 }