@arki/dot 0.1.4 → 0.3.0

package/src/cli/render-graph.ts

@@ -0,0 +1,88 @@
+/**
+ * Renderer for `dot explain --graph` / `dot doctor --graph`.
+ *
+ * Emits the app's pip graph as [Mermaid](https://mermaid.js.org) `flowchart`
+ * source — paste-able into GitHub markdown, docs, and mermaid.live.
+ *
+ * The nodes are the pips in declaration order (which IS boot order in v2 —
+ * the numbering makes that visible); the edges are the manifest's
+ * **observed** dependency edges, recorded by the kernel when a pip's need
+ * was satisfied during boot. `explain` never boots, so its graph shows
+ * declaration order with whatever edges configure-time metadata declared;
+ * `doctor` boots, so its graph shows the real wiring.
+ */
+
+import type { DotAppManifest } from '../manifest.js';
+import type { DotCliEnvelope, RenderOptions } from './render-explain.js';
+
+/** Envelope payload for graph output. */
+export type GraphData = {
+  format: 'mermaid';
+  /** Mermaid `flowchart` source. */
+  source: string;
+};
+
+/** Escape a pip name for use inside a quoted Mermaid node label. */
+function escapeLabel(name: string): string {
+  return name.replaceAll('"', '#quot;');
+}
+
+/**
+ * Build Mermaid `flowchart` source from a manifest. Deterministic: node
+ * ids follow declaration order, edges follow manifest order.
+ */
+export function buildMermaidGraph(manifest: DotAppManifest): string {
+  const lines: string[] = ['flowchart TD'];
+  const idByPip = new Map<string, string>();
+
+  for (const [index, pip] of manifest.pips.entries()) {
+    const id = `p${index.toString()}`;
+    idByPip.set(pip.name, id);
+    const order = (index + 1).toString();
+    const version = pip.version === undefined ? '' : `@${pip.version}`;
+    lines.push(`  ${id}["${order} · ${escapeLabel(pip.name)}${escapeLabel(version)}"]`);
+  }
+
+  for (const edge of manifest.dependencies) {
+    const from = idByPip.get(edge.from);
+    const to = idByPip.get(edge.to);
+    // Edges referencing unknown pips would be a kernel bug — skip rather
+    // than emit invalid Mermaid.
+    if (from === undefined || to === undefined) continue;
+    lines.push(`  ${from} -->|${edge.kind}| ${to}`);
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+/**
+ * Render the graph output. Plain mode prints raw Mermaid source (pipe it
+ * straight into a markdown code fence); `--json` wraps it in the standard
+ * CLI envelope under `data.source`.
+ */
+export function renderGraph(
+  source: { manifest: DotAppManifest; command: 'explain' | 'doctor' },
+  opts: RenderOptions,
+): DotCliEnvelope<GraphData> {
+  const mermaid = buildMermaidGraph(source.manifest);
+  const nowFactory = opts.now ?? (() => new Date());
+  const envelope: DotCliEnvelope<GraphData> = {
+    status: 'success',
+    command: source.command,
+    generatedAt: nowFactory().toISOString(),
+    data: { format: 'mermaid', source: mermaid },
+    errors: [],
+  };
+
+  const out =
+    opts.out ??
+    ((line: string) => {
+      process.stdout.write(line);
+    });
+  if (opts.json) {
+    out(`${JSON.stringify(envelope, null, 2)}\n`);
+  } else {
+    out(mermaid);
+  }
+  return envelope;
+}

package/src/cli/render-openapi.ts

@@ -0,0 +1,147 @@
+/**
+ * Renderer for `dot explain --openapi`.
+ *
+ * Emits an OpenAPI 3.1 document straight from `manifest.routes` — no boot
+ * required. Adapters (e.g. `@arki/http`'s `registerRoutes`) convert their
+ * validation schemas to JSON Schema at `configure` time and register them
+ * via `ctx.registerRoute`, so the manifest already carries everything the
+ * document needs: methods, paths, per-location input schemas, output
+ * schemas, and the `streaming` flag for `text/event-stream` responses.
+ *
+ * Deterministic: paths and operations follow manifest registration order
+ * (which follows pip declaration order). Only `transport: 'http'` routes
+ * are rendered — rpc mounts have their own schema story.
+ */
+
+import type { DotAppManifest, RouteManifest } from '../manifest.js';
+import type { DotCliEnvelope, RenderOptions } from './render-explain.js';
+
+/** Envelope payload for OpenAPI output. */
+export type OpenApiData = {
+  format: 'openapi';
+  /** OpenAPI 3.1 document. */
+  document: Record<string, unknown>;
+};
+
+function openApiPath(path: string): string {
+  return path.replaceAll(/:(\w+)/g, '{$1}');
+}
+
+function pathParamNames(path: string): readonly string[] {
+  return [...path.matchAll(/:(\w+)/g)]
+    .map(match => match[1])
+    .filter((name): name is string => name !== undefined);
+}
+
+function buildOperation(route: RouteManifest): Record<string, unknown> {
+  const parameters: Record<string, unknown>[] = pathParamNames(route.path ?? '').map(name => ({
+    name,
+    in: 'path',
+    required: true,
+    schema: { type: 'string' },
+  }));
+
+  const querySchema = route.input?.query;
+  if (querySchema !== undefined) {
+    const properties = (querySchema['properties'] ?? {}) as Readonly<Record<string, unknown>>;
+    const required = new Set(querySchema['required'] as readonly string[] | undefined);
+    for (const [name, propertySchema] of Object.entries(properties)) {
+      parameters.push({ name, in: 'query', required: required.has(name), schema: propertySchema });
+    }
+  }
+
+  const operation: Record<string, unknown> = {
+    operationId: route.id,
+    tags: [route.pip],
+  };
+  if (route.description !== undefined) operation['summary'] = route.description;
+  if (parameters.length > 0) operation['parameters'] = parameters;
+
+  const bodySchema = route.input?.body;
+  if (bodySchema !== undefined) {
+    operation['requestBody'] = {
+      required: true,
+      content: { 'application/json': { schema: bodySchema } },
+    };
+  }
+
+  if (route.streaming === true) {
+    operation['responses'] = {
+      '200': {
+        description: 'event stream',
+        content: {
+          'text/event-stream': route.output === undefined ? {} : { schema: route.output },
+        },
+      },
+    };
+  } else if (route.output === undefined) {
+    operation['responses'] = { '200': { description: 'success' } };
+  } else {
+    operation['responses'] = {
+      '200': {
+        description: 'success',
+        content: { 'application/json': { schema: route.output } },
+      },
+    };
+  }
+
+  return operation;
+}
+
+/**
+ * Build an OpenAPI 3.1 document from a manifest. First registration wins
+ * on a method+path collision — collisions are an app bug the serving
+ * adapter rejects at boot; the document renderer stays total.
+ */
+export function buildOpenApiDocument(manifest: DotAppManifest): Record<string, unknown> {
+  const paths: Record<string, Record<string, unknown>> = {};
+  for (const route of manifest.routes) {
+    if (route.transport !== 'http') continue;
+    if (route.path === undefined) continue;
+    const path = openApiPath(route.path);
+    const method = (route.method ?? 'GET').toLowerCase();
+    const entry = (paths[path] ??= {});
+    if (entry[method] !== undefined) continue;
+    entry[method] = buildOperation(route);
+  }
+  return {
+    openapi: '3.1.0',
+    info: {
+      title: manifest.app.name,
+      version: manifest.app.version ?? '0.0.0',
+    },
+    paths,
+  };
+}
+
+/**
+ * Render the OpenAPI output. Plain mode prints the document as JSON
+ * (pipe it into a file or a swagger viewer); `--json` wraps it in the
+ * standard CLI envelope under `data.document`.
+ */
+export function renderOpenApi(
+  source: { manifest: DotAppManifest; command: 'explain' },
+  opts: RenderOptions,
+): DotCliEnvelope<OpenApiData> {
+  const document = buildOpenApiDocument(source.manifest);
+  const nowFactory = opts.now ?? (() => new Date());
+  const envelope: DotCliEnvelope<OpenApiData> = {
+    status: 'success',
+    command: source.command,
+    generatedAt: nowFactory().toISOString(),
+    data: { format: 'openapi', document },
+    errors: [],
+  };
+
+  const out =
+    opts.out ??
+    ((line: string) => {
+      process.stdout.write(line);
+    });
+  if (opts.json) {
+    out(`${JSON.stringify(envelope, null, 2)}\n`);
+  } else {
+    out(`${JSON.stringify(document, null, 2)}\n`);
+  }
+  return envelope;
+}

package/src/define-app.ts

@@ -176,6 +176,7 @@ type BuilderState = {
   pips: AnyPip[];
   config?: Readonly<Record<string, unknown>>;
   observers?: readonly DotLifecycleObserver[];
+  hookTimeoutMs?: number;
 };
 
 /**
@@ -204,6 +205,16 @@ export function defineApp(
      * `configured.subscribe(...)` or `app.subscribe(...)`.
      */
     observers?: readonly DotLifecycleObserver[];
+    /**
+     * Watchdog budget (ms) for each async hook invocation (`boot`, `start`,
+     * `stop`, `dispose` — `configure` is sync). A hook exceeding the budget
+     * fails with `DOT_LIFECYCLE_E015` naming the pip and hook, and the
+     * kernel applies its normal failure rules (boot rollback, teardown
+     * aggregation). The hook's promise itself cannot be cancelled — the
+     * watchdog makes the hang *visible*, it does not kill it. Default:
+     * no watchdog.
+     */
+    hookTimeoutMs?: number;
   } = {},
 ): DotAppBuilder<EmptyShape> {
   const state: BuilderState = {
@@ -212,6 +223,7 @@ export function defineApp(
     pips: [],
     config: options.config,
     observers: options.observers,
+    hookTimeoutMs: options.hookTimeoutMs,
   };
   return makeBuilder<EmptyShape>(state);
 }
@@ -223,6 +235,7 @@ function buildImpl(state: BuilderState): DotAppImpl {
     pips: state.pips,
     config: state.config,
     observers: state.observers,
+    hookTimeoutMs: state.hookTimeoutMs,
   });
 }
 

package/src/index.ts

@@ -20,6 +20,7 @@ export type {
   CtxOf,
   DotConfigureContext,
   EmptyShape,
+  InferredProvides,
   KernelCtx,
   Lazy,
   LazyService,
@@ -80,8 +81,11 @@ export type {
 export { renderTimeline } from './timeline.js';
 export type { RenderTimelineOptions } from './timeline.js';
 
-export { testApp, bootTestApp } from './test-harness.js';
-export type { TestAppOptions } from './test-harness.js';
+export { testApp, bootTestApp, testPip } from './test-harness.js';
+export type { TestAppOptions, TestPipBuilder } from './test-harness.js';
+
+export { hookSignals } from './signals.js';
+export type { HookSignalsOptions, SignalTarget } from './signals.js';
 
 // Task 9b: CLI envelope type is exported so adapter packages can produce the
 // same shape from related tooling (release-tooling, pip scaffolds, etc.).

package/src/kernel/app-instance.ts

@@ -104,6 +104,8 @@ export type DotAppInternalConfig = {
    * happen before there's a public seam to call `subscribe()` on.
    */
   observers?: readonly DotLifecycleObserver[];
+  /** Per-hook watchdog budget in ms — see `defineApp`'s option of the same name. */
+  hookTimeoutMs?: number;
 };
 
 /**
@@ -122,6 +124,9 @@ export class DotAppImpl {
   /** Macro-state of the app. */
   #state: DotLifecycleState = 'defined';
 
+  /** Per-hook watchdog budget (ms); `undefined` = no watchdog. */
+  readonly #hookTimeoutMs: number | undefined;
+
   /** Manifest finalised after `configure`. */
   #manifest: DotAppManifest;
 
@@ -180,6 +185,7 @@ export class DotAppImpl {
   constructor(config: DotAppInternalConfig) {
     this.#appName = config.appName;
     this.#appVersion = config.appVersion;
+    this.#hookTimeoutMs = config.hookTimeoutMs;
     this.#config = Object.freeze({ ...config.config });
     this.#logger = new Logger('arki:dot:lifecycle', { 'dot.app.name': config.appName });
     this.#observers = new Set(config.observers);
@@ -675,6 +681,44 @@ export class DotAppImpl {
     return ctx;
   }
 
+  /**
+   * Race one hook invocation against the app's `hookTimeoutMs` watchdog.
+   * No budget configured → plain pass-through. On timeout the returned
+   * promise rejects with `DOT_LIFECYCLE_E015` naming the pip and hook,
+   * and the call site's existing catch path applies the phase's normal
+   * failure rules (boot rollback, start cascade, teardown aggregation).
+   * The hook's own promise cannot be cancelled — the watchdog makes a
+   * hang visible and bounded; it does not kill the hung work.
+   */
+  async #withHookBudget<T>(pipName: string, hook: DotLifecycleHook, run: () => Promise<T> | T): Promise<T> {
+    const budget = this.#hookTimeoutMs;
+    if (budget === undefined) return run();
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const watchdog = new Promise<never>((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new DotLifecycleError({
+            code: DotLifecycleErrorCode.HookTimeout,
+            phase: hook,
+            pip: pipName,
+            message:
+              `${hook} hook of pip "${pipName}" exceeded the ${budget.toString()}ms hookTimeoutMs watchdog. ` +
+              `The kernel treats the hook as failed and applies its normal rollback/aggregation rules, but ` +
+              `cannot cancel the hook's promise — find the hang (a missing await? a connection that never ` +
+              `settles?) or raise the budget in defineApp(name, { hookTimeoutMs }).`,
+          }),
+        );
+      }, budget);
+      // A pending watchdog must never keep an otherwise-finished process alive.
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([Promise.resolve(run()), watchdog]);
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+    }
+  }
+
   /**
    * Inner boot loop. Separated from `#runBoot` so the phase span wrapper
    * stays thin and the loop body — which orchestrates rollback on
@@ -770,26 +814,33 @@ export class DotAppImpl {
       this.#emitHook('boot', pip.name, record.order, 'starting');
       let result: ServiceRecord | void;
       try {
-        result = await withPipHookSpan(
-          {
-            appName: this.#appName,
-            pipName: pip.name,
-            pipVersion: pip.version,
-            hook: 'boot',
-            order: record.order,
-            logger: pipLogger,
-          },
-          // Erasure boundary: hooks are stored as `(ctx: never) => ...`;
-          // the kernel is the one caller allowed to cross it.
-          () => pip.hooks.boot!(ctx as never),
+        result = await this.#withHookBudget(pip.name, 'boot', () =>
+          withPipHookSpan(
+            {
+              appName: this.#appName,
+              pipName: pip.name,
+              pipVersion: pip.version,
+              hook: 'boot',
+              order: record.order,
+              logger: pipLogger,
+            },
+            // Erasure boundary: hooks are stored as `(ctx: never) => ...`;
+            // the kernel is the one caller allowed to cross it.
+            () => pip.hooks.boot!(ctx as never),
+          ),
         );
       } catch (error) {
+        const timedOut = error instanceof DotLifecycleError && error.code === DotLifecycleErrorCode.HookTimeout;
         return fail({
           record,
-          code: DotLifecycleErrorCode.BootFailed,
-          message: `boot hook threw for pip "${pip.name}": ${stringifyError(error)}`,
-          remediation: `Fix the error in the boot() hook of "${pip.name}". If boot opens partial resources before throwing, clean them up locally — DOT only disposes pips whose boot completed.`,
-          docsAnchor: 'boot-failed',
+          code: timedOut ? DotLifecycleErrorCode.HookTimeout : DotLifecycleErrorCode.BootFailed,
+          message: timedOut
+            ? error.message
+            : `boot hook threw for pip "${pip.name}": ${stringifyError(error)}`,
+          remediation: timedOut
+            ? `Find the hang in the boot() hook of "${pip.name}" — a missing await or a connection that never settles — or raise defineApp's hookTimeoutMs.`
+            : `Fix the error in the boot() hook of "${pip.name}". If boot opens partial resources before throwing, clean them up locally — DOT only disposes pips whose boot completed.`,
+          docsAnchor: timedOut ? 'hook-timeout' : 'boot-failed',
           durationMs: performance.now() - started,
           cause: error,
           rollback: bootedRecords,
@@ -917,25 +968,32 @@ export class DotAppImpl {
       const startedAt = performance.now();
       this.#emitHook('start', pip.name, record.order, 'starting');
       try {
-        await withPipHookSpan(
-          {
-            appName: this.#appName,
-            pipName: pip.name,
-            pipVersion: pip.version,
-            hook: 'start',
-            order: record.order,
-            logger: pipLogger,
-          },
-          () => pip.hooks.start!(ctx as never),
+        await this.#withHookBudget(pip.name, 'start', () =>
+          withPipHookSpan(
+            {
+              appName: this.#appName,
+              pipName: pip.name,
+              pipVersion: pip.version,
+              hook: 'start',
+              order: record.order,
+              logger: pipLogger,
+            },
+            () => pip.hooks.start!(ctx as never),
+          ),
         );
       } catch (error) {
         const durationMs = performance.now() - startedAt;
+        const timedOut = error instanceof DotLifecycleError && error.code === DotLifecycleErrorCode.HookTimeout;
         const issue = makeIssue({
-          code: DotLifecycleErrorCode.StartFailed,
+          code: timedOut ? DotLifecycleErrorCode.HookTimeout : DotLifecycleErrorCode.StartFailed,
           pip: pip.name,
-          message: `start hook threw for pip "${pip.name}": ${stringifyError(error)}`,
-          remediation: `Fix the error in the start() hook of "${pip.name}". DOT will stop all already-started pips and dispose all booted pips in reverse order.`,
-          docsAnchor: 'start-failed',
+          message: timedOut
+            ? error.message
+            : `start hook threw for pip "${pip.name}": ${stringifyError(error)}`,
+          remediation: timedOut
+            ? `Find the hang in the start() hook of "${pip.name}" — or raise defineApp's hookTimeoutMs. DOT rolls back as for any start failure.`
+            : `Fix the error in the start() hook of "${pip.name}". DOT will stop all already-started pips and dispose all booted pips in reverse order.`,
+          docsAnchor: timedOut ? 'hook-timeout' : 'start-failed',
         });
         record.issues.push(issue);
         record.lifecycleDiagnostics.push({
@@ -958,7 +1016,7 @@ export class DotAppImpl {
         this.#manifest = this.#buildManifest();
         const failures = [...stopFailures, ...disposeFailures];
         throw new DotLifecycleError({
-          code: DotLifecycleErrorCode.StartFailed,
+          code: timedOut ? DotLifecycleErrorCode.HookTimeout : DotLifecycleErrorCode.StartFailed,
           phase: 'start',
           pip: pip.name,
           message: issue.message,
@@ -1053,16 +1111,18 @@ export class DotAppImpl {
       const startedAt = performance.now();
       this.#emitHook('stop', record.pip.name, record.order, 'starting');
       try {
-        await withPipHookSpan(
-          {
-            appName: this.#appName,
-            pipName: record.pip.name,
-            pipVersion: record.pip.version,
-            hook: 'stop',
-            order: record.order,
-            logger: pipLogger,
-          },
-          () => record.pip.hooks.stop!(ctx as never),
+        await this.#withHookBudget(record.pip.name, 'stop', () =>
+          withPipHookSpan(
+            {
+              appName: this.#appName,
+              pipName: record.pip.name,
+              pipVersion: record.pip.version,
+              hook: 'stop',
+              order: record.order,
+              logger: pipLogger,
+            },
+            () => record.pip.hooks.stop!(ctx as never),
+          ),
         );
         record.started = false;
         const durationMs = performance.now() - startedAt;
@@ -1265,16 +1325,18 @@ export class DotAppImpl {
       const startedAt = performance.now();
       this.#emitHook('dispose', record.pip.name, record.order, 'starting');
       try {
-        await withPipHookSpan(
-          {
-            appName: this.#appName,
-            pipName: record.pip.name,
-            pipVersion: record.pip.version,
-            hook: 'dispose',
-            order: record.order,
-            logger: pipLogger,
-          },
-          () => record.pip.hooks.dispose!(ctx as never),
+        await this.#withHookBudget(record.pip.name, 'dispose', () =>
+          withPipHookSpan(
+            {
+              appName: this.#appName,
+              pipName: record.pip.name,
+              pipVersion: record.pip.version,
+              hook: 'dispose',
+              order: record.order,
+              logger: pipLogger,
+            },
+            () => record.pip.hooks.dispose!(ctx as never),
+          ),
         );
         record.booted = false;
         const durationMs = performance.now() - startedAt;

package/src/lifecycle.ts

@@ -76,6 +76,8 @@ export const DotLifecycleErrorCode = {
   ServiceCollision: 'DOT_LIFECYCLE_E013',
   /** A needs alias, publish key, or rename target uses the reserved `$` prefix. */
   ReservedServiceKey: 'DOT_LIFECYCLE_E014',
+  /** A lifecycle hook exceeded the app's `hookTimeoutMs` watchdog. */
+  HookTimeout: 'DOT_LIFECYCLE_E015',
 } as const;
 
 export type DotLifecycleErrorCodeValue = (typeof DotLifecycleErrorCode)[keyof typeof DotLifecycleErrorCode];

package/src/manifest.ts

@@ -71,6 +71,25 @@ export type RouteManifest = {
   method?: string;
   path?: string;
   transport: RouteTransport;
+  /** Human summary, rendered into docs/OpenAPI output. */
+  description?: string;
+  /**
+   * JSON Schema for the request inputs, keyed by location. Adapters
+   * convert their validation schemas (e.g. zod) at `configure` time so the
+   * manifest stays plain serializable data — `dot explain --openapi`
+   * renders straight from here without booting.
+   */
+  input?: {
+    readonly query?: Readonly<Record<string, unknown>>;
+    readonly body?: Readonly<Record<string, unknown>>;
+  };
+  /** JSON Schema for the success response (or per-event schema when `streaming`). */
+  output?: Readonly<Record<string, unknown>>;
+  /**
+   * The response is an open stream (e.g. `text/event-stream`) rather than
+   * a single JSON document.
+   */
+  streaming?: boolean;
 };
 
 /** Single service published by a pip. */

package/src/pip-contract.ts

@@ -313,8 +313,25 @@ export type DotConfigureContext = {
    * is returned from the `boot` hook.
    */
   registerService(name: string, kind: ServiceKind): void;
-  /** Register a route this pip exposes. */
-  registerRoute(route: { id: string; method?: string; path?: string; transport: RouteTransport }): void;
+  /**
+   * Register a route this pip exposes. The optional `description`,
+   * `input`/`output` JSON Schemas, and `streaming` flag flow into
+   * `manifest.routes` untouched — `dot explain --openapi` renders from
+   * them without booting the app.
+   */
+  registerRoute(route: {
+    id: string;
+    method?: string;
+    path?: string;
+    transport: RouteTransport;
+    description?: string;
+    input?: {
+      readonly query?: Readonly<Record<string, unknown>>;
+      readonly body?: Readonly<Record<string, unknown>>;
+    };
+    output?: Readonly<Record<string, unknown>>;
+    streaming?: boolean;
+  }): void;
   /** Mark the pip as participating in a lifecycle hook. */
   registerLifecycleHook(hook: 'configure' | 'boot' | 'start' | 'stop' | 'dispose'): void;
   /** Append `provides` capability strings (informational, manifest-only). */
@@ -393,6 +410,17 @@ export type AnyPip = Pip<ServiceRecord, ServiceRecord>;
  * });
  * ```
  */
+/**
+ * A `boot` that returns `void` gives `TProvides` no inference candidate,
+ * and TypeScript then substitutes the CONSTRAINT (`ServiceRecord & …`,
+ * whose `keyof` is `string`) rather than the declared default. That wide
+ * record would poison the app builder's collision check for every later
+ * `.use()` — `keyof TAvail & string` is never empty. Detect the fallback
+ * by its tell (a full string index signature — no `pip()`-authored
+ * provides record has one) and collapse it to "provides nothing".
+ */
+export type InferredProvides<TP extends ServiceRecord> = string extends keyof TP ? EmptyShape : TP;
+
 export function pip<
   TShape extends NeedsShape & NoReservedKeys = EmptyShape,
   TProvides extends ServiceRecord & NoReservedKeys = EmptyShape,
@@ -405,7 +433,7 @@ export function pip<
   readonly start?: (ctx: CtxOf<TShape> & TProvides & KernelCtx) => MaybePromise<void>;
   readonly stop?: (ctx: CtxOf<TShape> & TProvides & KernelCtx) => MaybePromise<void>;
   readonly dispose?: (ctx: CtxOf<TShape> & TProvides & KernelCtx) => MaybePromise<void>;
-}): Pip<WireNeeds<TShape>, TProvides> {
+}): Pip<WireNeeds<TShape>, InferredProvides<TProvides>> {
   return {
     name: def.name,
     ...(def.version === undefined ? {} : { version: def.version }),

package/src/pip.ts

@@ -21,6 +21,7 @@ export type {
   CtxOf,
   DotConfigureContext,
   EmptyShape,
+  InferredProvides,
   KernelCtx,
   Lazy,
   LazyService,