@makaio/contracts 1.0.0-dev-1779051654000

package/dist/client/account-identity.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Account and identity schemas for the client domain.
+ *
+ * Covers identifiers, usage windows, scan targets, usage snapshots,
+ * session locators, identity observations, and the account-observe /
+ * usage-ingest request–response pairs.
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Strength classification for a client account identifier.
+ */
+export declare const ClientIdentifierStrengthSchema: z.ZodEnum<{
+    alias: "alias";
+    strong: "strong";
+}>;
+export type ClientIdentifierStrength = z.infer<typeof ClientIdentifierStrengthSchema>;
+/**
+ * A canonical or derived identifier for a client account.
+ */
+export declare const ClientAccountIdentifierSchema: z.ZodObject<{
+    scheme: z.ZodString;
+    value: z.ZodString;
+    strength: z.ZodEnum<{
+        alias: "alias";
+        strong: "strong";
+    }>;
+}, z.core.$strip>;
+export type ClientAccountIdentifier = z.infer<typeof ClientAccountIdentifierSchema>;
+/**
+ * A normalized usage window for a client account.
+ */
+export declare const ClientUsageWindowSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    usedPercentage: z.ZodNumber;
+    resetsAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ClientUsageWindow = z.infer<typeof ClientUsageWindowSchema>;
+/**
+ * The usage windows container shared by snapshot and ingest schemas.
+ */
+export declare const ClientUsageWindowsSchema: z.ZodObject<{
+    windows: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        usedPercentage: z.ZodNumber;
+        resetsAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ClientUsageWindows = z.infer<typeof ClientUsageWindowsSchema>;
+/**
+ * Open metadata map shared by client account and usage contracts.
+ */
+export declare const ClientMetadataSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+/**
+ * A detected client binary scan result.
+ */
+export declare const ClientScanResultSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    found: z.ZodBoolean;
+    version: z.ZodOptional<z.ZodString>;
+    warningMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClientScanResult = z.infer<typeof ClientScanResultSchema>;
+/**
+ * Explicit CLI scan target supplied by callers that already resolved clients.
+ *
+ * `binaryName` is the resolved executable name for PATH lookup — kept as a
+ * flat field because this is a resolved scan parameter, not a definition
+ * shape. `supportedVersions` is the semver range used to validate the
+ * detected binary version.
+ */
+export declare const ClientScanTargetSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    binaryName: z.ZodString;
+    supportedVersions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClientScanTarget = z.infer<typeof ClientScanTargetSchema>;
+/**
+ * Canonical usage snapshot emitted after stitching identity and usage.
+ */
+export declare const ClientUsageSnapshotSchema: z.ZodObject<{
+    clientAccountId: z.ZodString;
+    clientId: z.ZodString;
+    observedAt: z.ZodNumber;
+    source: z.ZodString;
+    displayLabel: z.ZodOptional<z.ZodString>;
+    usage: z.ZodObject<{
+        windows: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            usedPercentage: z.ZodNumber;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ClientUsageSnapshot = z.infer<typeof ClientUsageSnapshotSchema>;
+/**
+ * Session locator used to correlate an observation to a session.
+ */
+export declare const ClientSessionLocatorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"session">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"adapter-session">;
+    adapterSessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"both">;
+    sessionId: z.ZodString;
+    adapterSessionId: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type ClientSessionLocator = z.infer<typeof ClientSessionLocatorSchema>;
+/**
+ * Raw client identity observation captured from a client runtime.
+ *
+ * These top-level fields stay syntactically permissive because adapters capture
+ * raw client evidence before canonical account-linking normalizes it. The
+ * persisted payload shape is still constrained to JSON so storage/event seams
+ * can safely serialize and snapshot observations.
+ */
+export declare const ClientIdentityObservationSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    source: z.ZodString;
+    kind: z.ZodString;
+    observedAt: z.ZodNumber;
+    payload: z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+}, z.core.$strip>;
+export type ClientIdentityObservation = z.infer<typeof ClientIdentityObservationSchema>;
+/**
+ * Request and response schemas for client.account.observe.
+ */
+export declare const ClientAccountObserveSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        observedAt: z.ZodOptional<z.ZodNumber>;
+        displayLabel: z.ZodOptional<z.ZodString>;
+        identifiers: z.ZodArray<z.ZodObject<{
+            scheme: z.ZodString;
+            value: z.ZodString;
+            strength: z.ZodEnum<{
+                alias: "alias";
+                strong: "strong";
+            }>;
+        }, z.core.$strip>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        clientAccountId: z.ZodString;
+        displayLabel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+export type ClientAccountObserveRequest = z.infer<typeof ClientAccountObserveSchema.request>;
+export type ClientAccountObserveResponse = z.infer<typeof ClientAccountObserveSchema.response>;
+/**
+ * Request and response schemas for client.session.account.observe.
+ */
+export declare const ClientSessionAccountObserveSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        source: z.ZodString;
+        kind: z.ZodString;
+        observedAt: z.ZodNumber;
+        payload: z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+        locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"session">;
+            sessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"adapter-session">;
+            adapterSessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"both">;
+            sessionId: z.ZodString;
+            adapterSessionId: z.ZodString;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        handled: z.ZodBoolean;
+        sessionId: z.ZodNullable<z.ZodString>;
+        clientAccountId: z.ZodNullable<z.ZodString>;
+        changed: z.ZodBoolean;
+    }, z.core.$strip>;
+};
+export type ClientSessionAccountObserveRequest = z.infer<typeof ClientSessionAccountObserveSchema.request>;
+export type ClientSessionAccountObserveResponse = z.infer<typeof ClientSessionAccountObserveSchema.response>;
+/**
+ * Request and response schemas for client.usage.ingest.
+ */
+export declare const ClientUsageIngestSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        observedAt: z.ZodNumber;
+        source: z.ZodString;
+        account: z.ZodObject<{
+            displayLabel: z.ZodOptional<z.ZodString>;
+            identifiers: z.ZodArray<z.ZodObject<{
+                scheme: z.ZodString;
+                value: z.ZodString;
+                strength: z.ZodEnum<{
+                    alias: "alias";
+                    strong: "strong";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        usage: z.ZodObject<{
+            windows: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                label: z.ZodString;
+                usedPercentage: z.ZodNumber;
+                resetsAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        clientAccountId: z.ZodString;
+        snapshot: z.ZodObject<{
+            clientAccountId: z.ZodString;
+            clientId: z.ZodString;
+            observedAt: z.ZodNumber;
+            source: z.ZodString;
+            displayLabel: z.ZodOptional<z.ZodString>;
+            usage: z.ZodObject<{
+                windows: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                    usedPercentage: z.ZodNumber;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+};
+export type ClientUsageIngestRequest = z.infer<typeof ClientUsageIngestSchema.request>;
+export type ClientUsageIngestResponse = z.infer<typeof ClientUsageIngestSchema.response>;
+//# sourceMappingURL=account-identity.d.ts.map

package/dist/client/account-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-identity.d.ts","sourceRoot":"","sources":["../../src/client/account-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;EAA8B,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;iBAIxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;iBAEnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,oBAAoB,uDAA+C,CAAC;AAEjF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;iBAQpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;2BAcrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;;;;;;iBAM1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;CAYtC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,OAAO,CAAC,CAAC;AAC7F,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,QAAQ,CAAC,CAAC;AAE/F;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;CAU7C,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,OAAO,CAAC,CAAC;AAC3G,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,QAAQ,CAAC,CAAC;AAE7G;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBnC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAC;AACvF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/client/binary-management.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Binary management schemas for the client domain.
+ *
+ * Covers install strategies, installed version entries, pinned version metadata,
+ * the `client.list` / `client.install` / `client.uninstall` / `client.update` /
+ * `client.setActive` command–response pairs, and the install-job progress and
+ * completion event payloads.
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Install strategies that Makaio supports for managed client binaries.
+ *
+ * - `npm`                  — npm registry installation with an exact version pin.
+ * - `signed-binary-bucket` — signed static bucket download with an exact version pin.
+ */
+export declare const ManagedInstallStrategySchema: z.ZodEnum<{
+    npm: "npm";
+    "signed-binary-bucket": "signed-binary-bucket";
+}>;
+export type ManagedInstallStrategy = z.infer<typeof ManagedInstallStrategySchema>;
+/**
+ * A single installed version entry for a managed client binary.
+ */
+export declare const InstalledVersionEntrySchema: z.ZodObject<{
+    version: z.ZodString;
+    installPath: z.ZodString;
+    installedAt: z.ZodNumber;
+    isActive: z.ZodBoolean;
+}, z.core.$strip>;
+export type InstalledVersionEntry = z.infer<typeof InstalledVersionEntrySchema>;
+/**
+ * Summary row for a single client in a `client.list` response.
+ */
+export declare const ClientBinaryListEntrySchema: z.ZodObject<{
+    clientId: z.ZodString;
+    installedVersions: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        installPath: z.ZodString;
+        installedAt: z.ZodNumber;
+        isActive: z.ZodBoolean;
+    }, z.core.$strip>>;
+    activeVersion: z.ZodNullable<z.ZodString>;
+    pinnedVersion: z.ZodString;
+    updateAvailable: z.ZodBoolean;
+}, z.core.$strict>;
+export type ClientBinaryListEntry = z.infer<typeof ClientBinaryListEntrySchema>;
+/**
+ * Request and response schemas for `client.list`.
+ *
+ * Returns the local installation inventory for all managed clients, including
+ * their pinned version and whether the active version matches the current pin.
+ */
+export declare const ClientListSchema: {
+    request: z.ZodObject<{
+        forceRefresh: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        clients: z.ZodArray<z.ZodObject<{
+            clientId: z.ZodString;
+            installedVersions: z.ZodArray<z.ZodObject<{
+                version: z.ZodString;
+                installPath: z.ZodString;
+                installedAt: z.ZodNumber;
+                isActive: z.ZodBoolean;
+            }, z.core.$strip>>;
+            activeVersion: z.ZodNullable<z.ZodString>;
+            pinnedVersion: z.ZodString;
+            updateAvailable: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strip>;
+};
+export type ClientListRequest = z.infer<typeof ClientListSchema.request>;
+export type ClientListResponse = z.infer<typeof ClientListSchema.response>;
+/**
+ * Request and response schemas for `client.install`.
+ *
+ * Enqueues a background install job for a managed client binary.
+ * Callers can track progress via `client.installJob.progress` and
+ * `client.installJob.completed` events using the returned `jobId`.
+ */
+export declare const ClientInstallSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        jobId: z.ZodString;
+        requestedVersion: z.ZodNullable<z.ZodString>;
+        resolvedVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+};
+export type ClientInstallRequest = z.infer<typeof ClientInstallSchema.request>;
+export type ClientInstallResponse = z.infer<typeof ClientInstallSchema.response>;
+/**
+ * Request and response schemas for `client.uninstall`.
+ *
+ * Removes a specific installed version of a managed client binary.
+ * If the removed version was active, the active pointer is cleared to `null`
+ * — no automatic replacement is made. Callers must explicitly call
+ * `client.setActive` to promote another installed version.
+ */
+export declare const ClientUninstallSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        clientId: z.ZodString;
+        removedVersion: z.ZodString;
+        activeVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+};
+export type ClientUninstallRequest = z.infer<typeof ClientUninstallSchema.request>;
+export type ClientUninstallResponse = z.infer<typeof ClientUninstallSchema.response>;
+/**
+ * Request and response schemas for `client.update`.
+ *
+ * Enqueues an update job that installs the client package pin and activates it.
+ * Callers can track progress via `client.installJob.progress` and
+ * `client.installJob.completed` events using the returned `jobId`.
+ */
+export declare const ClientUpdateSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        jobId: z.ZodString;
+        resolvedVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+};
+export type ClientUpdateRequest = z.infer<typeof ClientUpdateSchema.request>;
+export type ClientUpdateResponse = z.infer<typeof ClientUpdateSchema.response>;
+/**
+ * Request and response schemas for `client.setActive`.
+ *
+ * Switches the active binary pointer to an already-installed version.
+ * The requested version must be present on disk; the handler will reject
+ * requests for versions that have not been installed.
+ */
+export declare const ClientSetActiveSchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        clientId: z.ZodString;
+        activeVersion: z.ZodString;
+    }, z.core.$strip>;
+};
+export type ClientSetActiveRequest = z.infer<typeof ClientSetActiveSchema.request>;
+export type ClientSetActiveResponse = z.infer<typeof ClientSetActiveSchema.response>;
+/**
+ * Install pipeline stage identifiers, ordered by progression.
+ *
+ * - `'resolving'`    — determining the concrete version to install.
+ * - `'downloading'`  — fetching the binary archive from upstream.
+ * - `'verifying'`    — validating checksums, signatures, or installed binary version.
+ * - `'extracting'`   — unpacking the downloaded archive.
+ * - `'installing'`   — writing the binary to its final install path.
+ * - `'post-install'` — running post-install hooks.
+ * - `'activating'`   — marking the installed version as active.
+ */
+export declare const InstallStageSchema: z.ZodEnum<{
+    activating: "activating";
+    downloading: "downloading";
+    extracting: "extracting";
+    installing: "installing";
+    "post-install": "post-install";
+    resolving: "resolving";
+    verifying: "verifying";
+}>;
+export type InstallStage = z.infer<typeof InstallStageSchema>;
+/**
+ * Event payload for `client.installJob.progress`.
+ *
+ * Emitted by the install job runner at each pipeline stage transition and
+ * whenever the download progress percentage changes materially.
+ */
+export declare const ClientInstallProgressSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    clientId: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodEnum<{
+        npm: "npm";
+        "signed-binary-bucket": "signed-binary-bucket";
+    }>;
+    stage: z.ZodEnum<{
+        activating: "activating";
+        downloading: "downloading";
+        extracting: "extracting";
+        installing: "installing";
+        "post-install": "post-install";
+        resolving: "resolving";
+        verifying: "verifying";
+    }>;
+    progress: z.ZodNullable<z.ZodNumber>;
+    installPath: z.ZodOptional<z.ZodString>;
+    activeAfterCompletion: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ClientInstallProgress = z.infer<typeof ClientInstallProgressSchema>;
+/**
+ * Terminal install error descriptor emitted in `client.installJob.completed`
+ * when the job ends in failure.
+ */
+export declare const InstallErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InstallError = z.infer<typeof InstallErrorSchema>;
+/**
+ * Event payload for `client.installJob.completed`.
+ *
+ * Emitted once by the install job runner when the pipeline finishes,
+ * regardless of outcome. Listeners should check `status` before acting.
+ */
+export declare const ClientInstallCompletedSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    clientId: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodEnum<{
+        npm: "npm";
+        "signed-binary-bucket": "signed-binary-bucket";
+    }>;
+    status: z.ZodEnum<{
+        error: "error";
+        success: "success";
+    }>;
+    installPath: z.ZodOptional<z.ZodString>;
+    activeVersion: z.ZodNullable<z.ZodString>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ClientInstallCompleted = z.infer<typeof ClientInstallCompletedSchema>;
+/**
+ * Event payload for `client.version.changed`.
+ *
+ * Emitted whenever the active-version pointer for a managed client changes,
+ * regardless of the operation that caused the change.
+ */
+export declare const ClientVersionChangedSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    previousActiveVersion: z.ZodNullable<z.ZodString>;
+    activeVersion: z.ZodNullable<z.ZodString>;
+    reason: z.ZodEnum<{
+        install: "install";
+        "set-active": "set-active";
+        uninstall: "uninstall";
+        update: "update";
+    }>;
+}, z.core.$strip>;
+export type ClientVersionChanged = z.infer<typeof ClientVersionChangedSchema>;
+//# sourceMappingURL=binary-management.d.ts.map

package/dist/client/binary-management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-management.d.ts","sourceRoot":"","sources":["../../src/client/binary-management.ts"],"names":[],"mappings":"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"}

package/dist/client/binary-resolution.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Binary resolution schemas for the `client.resolveBinary` bus command.
+ *
+ * These schemas describe the execution context returned when resolving which
+ * binary to use for a given client, including the path, environment overrides,
+ * config directory, source, and version.
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Execution context returned by the `client.resolveBinary` command.
+ *
+ * Describes everything a caller needs to spawn the resolved client binary:
+ * the path (or `null` to use PATH lookup), environment overrides, the config
+ * directory in effect, the resolution source, and the resolved version.
+ */
+export declare const ClientExecutionContextSchema: z.ZodObject<{
+    binaryPath: z.ZodNullable<z.ZodString>;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    configDir: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        global: "global";
+        managed: "managed";
+    }>;
+    version: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ClientExecutionContext = z.infer<typeof ClientExecutionContextSchema>;
+/**
+ * Request and response schemas for `client.resolveBinary`.
+ *
+ * Resolves the binary path, environment overrides, and config directory for a
+ * given client. The response is everything a caller needs to spawn the binary.
+ *
+ * Phase 2 optional fields (`sessionId`, `projectDir`, `preferSource`,
+ * `harnessId`) are declared now as seams so the handler contract is stable
+ * before the implementations land.
+ */
+export declare const ClientResolveBinarySchema: {
+    request: z.ZodObject<{
+        clientId: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        projectDir: z.ZodOptional<z.ZodString>;
+        preferSource: z.ZodOptional<z.ZodEnum<{
+            global: "global";
+            managed: "managed";
+        }>>;
+        harnessId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        binaryPath: z.ZodNullable<z.ZodString>;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+        configDir: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            global: "global";
+            managed: "managed";
+        }>;
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+};
+export type ClientResolveBinaryRequest = z.infer<typeof ClientResolveBinarySchema.request>;
+export type ClientResolveBinaryResponse = z.infer<typeof ClientResolveBinarySchema.response>;
+//# sourceMappingURL=binary-resolution.d.ts.map

package/dist/client/binary-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-resolution.d.ts","sourceRoot":"","sources":["../../src/client/binary-resolution.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;iBAWvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;CAiBrC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,OAAO,CAAC,CAAC;AAC3F,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/client/create-definition.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Helper for creating static client definitions.
+ *
+ * This validates and normalizes static client definition literals at module
+ * initialization time so client packages get one canonical shape with schema
+ * defaults applied.
+ * @packageDocumentation
+ */
+import { type ClientDefinition, type ClientDefinitionInput } from './definition.js';
+/**
+ * Create an immutable client definition from a static object literal.
+ * @param definition - Client definition to return
+ * @returns Validated, normalized, frozen client definition
+ */
+export declare function createClientDefinition(definition: ClientDefinitionInput): ClientDefinition;
+//# sourceMappingURL=create-definition.d.ts.map

package/dist/client/create-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-definition.d.ts","sourceRoot":"","sources":["../../src/client/create-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAA0B,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AA4B5G;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,qBAAqB,GAAG,gBAAgB,CAE1F"}