@kilocode/client 0.0.0-stage → 0.0.0-v2-9

package/dist/promise/generated/types.js

@@ -0,0 +1,72 @@
+import {
+  isInvalidRequestError2,
+  isUnauthorizedError2,
+  isLocationNotFoundError2,
+  isServiceUnavailableError2,
+  isAgentNotFoundError2,
+  isInvalidCursorError2,
+  isSessionNotFoundError2,
+  isConflictError2,
+  isUnknownError2,
+  isMessageNotFoundError2,
+  isCommandNotFoundError2,
+  isCommandExecutionError2,
+  isSkillNotFoundError2,
+  isSessionBusyError2,
+  isInstructionEntryValueTooLargeError2,
+  isFormNotFoundError2,
+  isFormInvalidAnswerError2,
+  isFormAlreadySettledError2,
+  isProviderNotFoundError2,
+  isIntegrationNotFoundError2,
+  isIntegrationAttemptNotFoundError2,
+  isIntegrationMethodNotFoundError2,
+  isMcpServerNotFoundError2,
+  isForbiddenError2,
+  isProjectNotFoundError2,
+  isPermissionSavedNotFoundError2,
+  isPermissionNotFoundError2,
+  isFileNotFoundError2,
+  isRpcError2,
+  isRpcInternalError2,
+  isPtyNotFoundError2,
+  isShellNotFoundError2,
+  isWorktreeError2,
+  isVcsInitNotSupportedError2
+} from "../../chunks/contract-c46qzyff.js";
+export {
+  isAgentNotFoundError2 as isAgentNotFoundError,
+  isCommandExecutionError2 as isCommandExecutionError,
+  isCommandNotFoundError2 as isCommandNotFoundError,
+  isConflictError2 as isConflictError,
+  isFileNotFoundError2 as isFileNotFoundError,
+  isForbiddenError2 as isForbiddenError,
+  isFormAlreadySettledError2 as isFormAlreadySettledError,
+  isFormInvalidAnswerError2 as isFormInvalidAnswerError,
+  isFormNotFoundError2 as isFormNotFoundError,
+  isInstructionEntryValueTooLargeError2 as isInstructionEntryValueTooLargeError,
+  isIntegrationAttemptNotFoundError2 as isIntegrationAttemptNotFoundError,
+  isIntegrationMethodNotFoundError2 as isIntegrationMethodNotFoundError,
+  isIntegrationNotFoundError2 as isIntegrationNotFoundError,
+  isInvalidCursorError2 as isInvalidCursorError,
+  isInvalidRequestError2 as isInvalidRequestError,
+  isLocationNotFoundError2 as isLocationNotFoundError,
+  isMcpServerNotFoundError2 as isMcpServerNotFoundError,
+  isMessageNotFoundError2 as isMessageNotFoundError,
+  isPermissionNotFoundError2 as isPermissionNotFoundError,
+  isPermissionSavedNotFoundError2 as isPermissionSavedNotFoundError,
+  isProjectNotFoundError2 as isProjectNotFoundError,
+  isProviderNotFoundError2 as isProviderNotFoundError,
+  isPtyNotFoundError2 as isPtyNotFoundError,
+  isRpcError2 as isRpcError,
+  isRpcInternalError2 as isRpcInternalError,
+  isServiceUnavailableError2 as isServiceUnavailableError,
+  isSessionBusyError2 as isSessionBusyError,
+  isSessionNotFoundError2 as isSessionNotFoundError,
+  isShellNotFoundError2 as isShellNotFoundError,
+  isSkillNotFoundError2 as isSkillNotFoundError,
+  isUnauthorizedError2 as isUnauthorizedError,
+  isUnknownError2 as isUnknownError,
+  isVcsInitNotSupportedError2 as isVcsInitNotSupportedError,
+  isWorktreeError2 as isWorktreeError
+};

package/dist/promise/index.d.ts

@@ -0,0 +1,6 @@
+import type { OpenCode } from "./client.js";
+export * from "./generated/index.js";
+export { OpenCode } from "./client.js";
+export type { AgentApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, RpcApi, RpcCallOptions, RpcClient, RpcEventPayload, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
+export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types.js";
+export type OpenCodeClient = ReturnType<typeof OpenCode.make>;

package/dist/promise/index.js

@@ -0,0 +1,85 @@
+import"../chunks/contract-m2eywc8w.js";
+import {
+  exports_client3
+} from "../chunks/contract-vwtmm97t.js";
+import"../chunks/contract-vyas3vgt.js";
+import"../chunks/contract-s2hya144.js";
+import {
+  ClientError3
+} from "../chunks/contract-nwcpakzx.js";
+import"../chunks/contract-skhp7hxc.js";
+import {
+  isInvalidRequestError2,
+  isUnauthorizedError2,
+  isLocationNotFoundError2,
+  isServiceUnavailableError2,
+  isAgentNotFoundError2,
+  isInvalidCursorError2,
+  isSessionNotFoundError2,
+  isConflictError2,
+  isUnknownError2,
+  isMessageNotFoundError2,
+  isCommandNotFoundError2,
+  isCommandExecutionError2,
+  isSkillNotFoundError2,
+  isSessionBusyError2,
+  isInstructionEntryValueTooLargeError2,
+  isFormNotFoundError2,
+  isFormInvalidAnswerError2,
+  isFormAlreadySettledError2,
+  isProviderNotFoundError2,
+  isIntegrationNotFoundError2,
+  isIntegrationAttemptNotFoundError2,
+  isIntegrationMethodNotFoundError2,
+  isMcpServerNotFoundError2,
+  isForbiddenError2,
+  isProjectNotFoundError2,
+  isPermissionSavedNotFoundError2,
+  isPermissionNotFoundError2,
+  isFileNotFoundError2,
+  isRpcError2,
+  isRpcInternalError2,
+  isPtyNotFoundError2,
+  isShellNotFoundError2,
+  isWorktreeError2,
+  isVcsInitNotSupportedError2
+} from "../chunks/contract-c46qzyff.js";
+import"../chunks/contract-8bbb028w.js";
+export {
+  ClientError3 as ClientError,
+  exports_client3 as OpenCode,
+  isAgentNotFoundError2 as isAgentNotFoundError,
+  isCommandExecutionError2 as isCommandExecutionError,
+  isCommandNotFoundError2 as isCommandNotFoundError,
+  isConflictError2 as isConflictError,
+  isFileNotFoundError2 as isFileNotFoundError,
+  isForbiddenError2 as isForbiddenError,
+  isFormAlreadySettledError2 as isFormAlreadySettledError,
+  isFormInvalidAnswerError2 as isFormInvalidAnswerError,
+  isFormNotFoundError2 as isFormNotFoundError,
+  isInstructionEntryValueTooLargeError2 as isInstructionEntryValueTooLargeError,
+  isIntegrationAttemptNotFoundError2 as isIntegrationAttemptNotFoundError,
+  isIntegrationMethodNotFoundError2 as isIntegrationMethodNotFoundError,
+  isIntegrationNotFoundError2 as isIntegrationNotFoundError,
+  isInvalidCursorError2 as isInvalidCursorError,
+  isInvalidRequestError2 as isInvalidRequestError,
+  isLocationNotFoundError2 as isLocationNotFoundError,
+  isMcpServerNotFoundError2 as isMcpServerNotFoundError,
+  isMessageNotFoundError2 as isMessageNotFoundError,
+  isPermissionNotFoundError2 as isPermissionNotFoundError,
+  isPermissionSavedNotFoundError2 as isPermissionSavedNotFoundError,
+  isProjectNotFoundError2 as isProjectNotFoundError,
+  isProviderNotFoundError2 as isProviderNotFoundError,
+  isPtyNotFoundError2 as isPtyNotFoundError,
+  isRpcError2 as isRpcError,
+  isRpcInternalError2 as isRpcInternalError,
+  isServiceUnavailableError2 as isServiceUnavailableError,
+  isSessionBusyError2 as isSessionBusyError,
+  isSessionNotFoundError2 as isSessionNotFoundError,
+  isShellNotFoundError2 as isShellNotFoundError,
+  isSkillNotFoundError2 as isSkillNotFoundError,
+  isUnauthorizedError2 as isUnauthorizedError,
+  isUnknownError2 as isUnknownError,
+  isVcsInitNotSupportedError2 as isVcsInitNotSupportedError,
+  isWorktreeError2 as isWorktreeError
+};

package/dist/promise/rpc.d.ts

@@ -0,0 +1,32 @@
+import type { Rpc } from "@opencode/schema/rpc";
+import type { make, RequestOptions } from "./generated/client.js";
+import type { EventSubscribeOutput, LocationGetInput } from "./generated/types.js";
+type RpcEvent = Extract<EventSubscribeOutput, {
+    type: `rpc.${string}`;
+}>;
+export interface RpcCallOptions extends RequestOptions {
+    readonly location?: LocationGetInput["location"];
+}
+export type RpcArguments<Input, Options> = unknown extends Input ? [input: Input, options?: Options] : undefined extends Input ? [input?: Input, options?: Options] : [input: Input, options?: Options];
+export type RpcClient<D extends Rpc.PortableDefinition, Options = RpcCallOptions> = {
+    readonly [Name in keyof D["methods"]]: (...args: RpcArguments<Rpc.Input<D["methods"][Name]["input"]>, Options>) => Promise<Rpc.Output<D["methods"][Name]["output"]>>;
+} & {
+    readonly events: {
+        readonly subscribe: <Name extends keyof D["events"] & string>(name: Name, options?: Pick<RequestOptions, "signal">) => AsyncIterable<RpcEventPayload<D, Name>>;
+        readonly on: <Name extends keyof D["events"] & string>(name: Name, handler: (event: RpcEventPayload<D, Name>) => Promise<void> | void, options?: Pick<RequestOptions, "signal">) => () => void;
+    };
+};
+type RpcEventPayloadFor<D extends Rpc.PortableDefinition, Name extends keyof D["events"] & string> = Omit<RpcEvent, "type" | "data"> & {
+    type: `rpc.${D["id"]}.${Name}`;
+    data: Rpc.EventData<D["events"][Name]["schema"]>;
+};
+export type RpcEventPayload<D extends Rpc.PortableDefinition, Name extends keyof D["events"] & string = keyof D["events"] & string> = {
+    [K in Name]: RpcEventPayloadFor<D, K>;
+}[Name];
+export interface RpcApi<Options = RpcCallOptions> {
+    <D extends Rpc.PortableDefinition>(definition: D): RpcClient<D, Options>;
+}
+export declare function makeRpc(raw: ReturnType<typeof make>, events: {
+    subscribe(options?: Pick<RequestOptions, "signal">): AsyncIterable<EventSubscribeOutput>;
+}): RpcApi;
+export {};

package/dist/promise/rpc.js

@@ -0,0 +1,7 @@
+import {
+  makeRpc2
+} from "../chunks/contract-skhp7hxc.js";
+import"../chunks/contract-c46qzyff.js";
+export {
+  makeRpc2 as makeRpc
+};

package/dist/promise/service.d.ts

@@ -0,0 +1,24 @@
+import type { DiscoverOptions, Endpoint, EnsureOptions, StopOptions } from "../service.js";
+import { headers } from "../service-probe.js";
+export * from "../service.js";
+export { headers };
+/** Discover a healthy, compatible local service without starting one. */
+export declare function discover(options?: DiscoverOptions): Promise<{
+    url: string;
+    auth: {
+        type: "basic";
+        username: string;
+        password: string;
+    } | undefined;
+} | undefined>;
+/** Ensure a healthy, compatible local service is running. */
+export declare function ensure(options?: EnsureOptions): Promise<Endpoint>;
+/** Stop the registered local service. */
+export declare function stop(options?: StopOptions): Promise<void>;
+/** Promise-based local service lifecycle operations. */
+export declare const Service: {
+    discover: typeof discover;
+    ensure: typeof ensure;
+    stop: typeof stop;
+    headers: typeof headers;
+};

package/dist/promise/service.js

@@ -0,0 +1,187 @@
+import {
+  spawnServiceContender2,
+  contenderPool2
+} from "../chunks/contract-ve4aws36.js";
+import {
+  defaultEnsureTiming2,
+  ensureTiming2
+} from "../chunks/contract-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "../chunks/contract-sxt88q69.js";
+import {
+  decide2,
+  fallback2,
+  same2,
+  probeResult2,
+  headers2
+} from "../chunks/contract-8ye1ye6f.js";
+import {
+  prepare2,
+  environment2,
+  complete2,
+  clear2
+} from "../chunks/contract-5bf0yjkp.js";
+import"../chunks/contract-qav6mfdz.js";
+
+// src/promise/service.ts
+import { readFile, rm } from "node:fs/promises";
+async function discover(options = {}) {
+  const found = (await registered(options.file)).service;
+  if (found?.state !== "ready")
+    return;
+  if (!found.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return found.endpoint;
+}
+async function ensure(options = {}) {
+  const timing = ensureTiming2(options);
+  const deadline = Date.now() + timing.promiseTimeout;
+  const pool = contenderPool2(timing);
+  let timeouts;
+  let announced = false;
+  const announce = (reason, previousVersion) => {
+    if (announced)
+      return;
+    announced = true;
+    options.onStart?.(reason, previousVersion);
+  };
+  const spawnContender = async () => {
+    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+    if (command === undefined)
+      throw new Error("Missing service command");
+    try {
+      return spawnServiceContender2(command, args, await environment2(options.file ?? fallback2(), options.env));
+    } catch (cause) {
+      throw new Error("Failed to start server", { cause });
+    }
+  };
+  try {
+    while (true) {
+      if (Date.now() >= deadline)
+        throw pool.failure() ?? new Error("Timed out waiting for the background service to start");
+      const registration = await registered(options.file, timing.requestTimeout);
+      if (registration.timedOut && registration.info !== undefined) {
+        timeouts = {
+          info: registration.info,
+          count: timeouts !== undefined && same2(timeouts.info, registration.info) ? timeouts.count + 1 : 1
+        };
+        if (timeouts.count >= 3) {
+          announce("missing");
+          console.warn("Background service is unresponsive; recovery cannot preserve persistent terminals");
+          await clear2(options.file ?? fallback2());
+          await terminate(registration.info, options, timing);
+          pool.evict(registration.info.pid);
+          pool.recruitNow();
+          timeouts = undefined;
+        }
+      } else
+        timeouts = undefined;
+      if (registration.service !== undefined) {
+        pool.serviceAnswered();
+        const service2 = registration.service;
+        const decision = decide2(service2, options);
+        if (decision._tag === "fail")
+          throw decision.error;
+        if (decision._tag === "reuse") {
+          await complete2(options.file ?? fallback2(), service2.info);
+          return service2.endpoint;
+        }
+        if (decision._tag === "replace") {
+          announce("version-mismatch", service2.version);
+          if (service2.state !== "ready")
+            console.warn("Background service is not ready; replacement cannot preserve persistent terminals");
+          await stop({ file: options.file, pty: decision.pty }).catch(() => {
+            return;
+          });
+          pool.evict(service2.info.pid);
+        }
+      } else {
+        const failed = pool.reap();
+        if (failed !== undefined)
+          throw failed;
+        if (pool.shouldRecruit(registration.info !== undefined)) {
+          announce("missing");
+          pool.add(await spawnContender());
+        }
+      }
+      await delay(timing.pollInterval);
+    }
+  } finally {
+    pool.releaseAll();
+  }
+}
+async function stop(options = {}) {
+  const info = await read(options.file);
+  await (options.pty === "handoff" && info !== undefined ? prepare2(options.file ?? fallback2(), info, defaultEnsureTiming2.requestTimeout) : clear2(options.file ?? fallback2())).catch((cause) => console.warn("Failed to prepare persistent terminals for replacement", cause));
+  if (info !== undefined)
+    await terminate(info, options, ensureTiming2(options));
+}
+async function read(file) {
+  const text = await readFile(file ?? fallback2(), "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+async function registered(file, timeout) {
+  const info = await read(file);
+  if (info === undefined)
+    return { info: undefined, service: undefined, timedOut: false };
+  return { info, ...await probeResult2(info, timeout) };
+}
+function signal(pid, name) {
+  try {
+    process.kill(pid, name);
+  } catch {}
+}
+function stopped(pid) {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function waitUntilStopped(pid, timing) {
+  for (let attempt = 0;attempt <= timing.stopPollAttempts; attempt++) {
+    if (stopped(pid))
+      return true;
+    if (attempt < timing.stopPollAttempts)
+      await delay(timing.stopPollInterval);
+  }
+  return false;
+}
+async function terminate(info, options, timing) {
+  const current = await read(options.file);
+  if (current === undefined || !same2(current, info))
+    return;
+  signal(info.pid, "SIGTERM");
+  if (!await waitUntilStopped(info.pid, timing)) {
+    signal(info.pid, "SIGKILL");
+    if (!await waitUntilStopped(info.pid, timing))
+      throw new Error(`Server process ${info.pid} is still running`);
+  }
+  const latest = await read(options.file);
+  if (latest === undefined || !same2(latest, info))
+    return;
+  await rm(options.file ?? fallback2(), { force: true });
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+var Service = { discover, ensure, stop, headers: headers2 };
+export {
+  Service,
+  discover,
+  ensure,
+  headers2 as headers,
+  stop
+};

package/dist/pty-handoff.d.ts

@@ -0,0 +1,12 @@
+export * as PtyHandoff from "./pty-handoff.js";
+import type { Info } from "./service.js";
+/**
+ * Publish the ticket before stopping its owner so every replacement contender can adopt it.
+ * Never throws: terminals are best-effort, so any failure replaces the service without a handoff.
+ */
+export declare function prepare(file: string, info: Info, timeout: number): Promise<void>;
+export declare function environment(file: string, env?: Readonly<Record<string, string>>): Promise<{
+    OPENCODE_PTY_HANDOFF: string | undefined;
+}>;
+export declare function complete(file: string, info: Info): Promise<void>;
+export declare function clear(file: string): Promise<void>;

package/dist/pty-handoff.js

@@ -0,0 +1,17 @@
+import {
+  prepare2,
+  environment2,
+  complete2,
+  clear2,
+  exports_pty_handoff
+} from "./chunks/contract-5bf0yjkp.js";
+import"./chunks/contract-8ye1ye6f.js";
+import"./chunks/contract-xgnj2w4v.js";
+import"./chunks/contract-sxt88q69.js";
+export {
+  exports_pty_handoff as PtyHandoff,
+  clear2 as clear,
+  complete2 as complete,
+  environment2 as environment,
+  prepare2 as prepare
+};

package/dist/rpc-runtime.d.ts

@@ -0,0 +1,20 @@
+export * as RpcRuntime from "./rpc-runtime.js";
+import type { Rpc } from "@opencode/schema/rpc";
+import { Effect, Schema } from "effect";
+export declare function read(schema: Rpc.Method["output"], value: unknown): Effect.Effect<unknown, Schema.SchemaError, never>;
+export declare function readError(method: Rpc.Method, error: unknown): Effect.Effect<never, unknown>;
+export declare const event: <D extends Rpc.Definition, Name extends keyof D["events"] & string>(definition: D, name: Name, schema: Rpc.EventDefinition, event: {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly type: `rpc.${string}`;
+    readonly location: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+    };
+    readonly data: {
+        readonly [x: string]: unknown;
+    };
+}) => Effect.Effect<Rpc.EventPayload<D, Name>, unknown, never>;
+export declare function eventType<const D extends Rpc.Definition, const Name extends keyof D["events"] & string>(definition: D, name: Name): `rpc.${D["id"]}.${Name}`;

package/dist/rpc-runtime.js

@@ -0,0 +1,14 @@
+import {
+  read2,
+  readError2,
+  event2,
+  eventType2,
+  exports_rpc_runtime
+} from "./chunks/contract-ryy6kscr.js";
+export {
+  exports_rpc_runtime as RpcRuntime,
+  event2 as event,
+  eventType2 as eventType,
+  read2 as read,
+  readError2 as readError
+};

package/dist/service-contender.d.ts

@@ -0,0 +1,37 @@
+import { type ChildProcess } from "node:child_process";
+import type { EnsureTiming } from "./service-timing.js";
+export type ServiceContender = {
+    readonly child: ChildProcess;
+    readonly error: () => Error | undefined;
+    readonly closed: () => boolean;
+    readonly stderr: () => string;
+    readonly release: () => void;
+};
+export declare function spawnServiceContender(command: string, args: ReadonlyArray<string>, env?: Readonly<Record<string, string | undefined>>): ServiceContender;
+/**
+ * The startup attempts of one `ensure()` call. It keeps at most two attempts alive, remembers
+ * the first startup failure, and backs off when attempts exit cleanly because another one won.
+ */
+export declare function contenderPool(timing: EnsureTiming): {
+    /** The first startup failure seen since the last eviction. */
+    failure: () => Error | undefined;
+    /** A registered service answered, so the next attempt waits the base delay again. */
+    serviceAnswered(): void;
+    /**
+     * The owner `pid` was replaced. Drop its attempt and any finished ones, forget their
+     * failure, and restart the spawn clock.
+     */
+    evict(pid: number): void;
+    /** Let the next attempt start without waiting a spawn delay. */
+    recruitNow(): void;
+    /** Collect finished attempts. Returns the startup failure once no attempt is left alive. */
+    reap(): Error | undefined;
+    /**
+     * Whether to start another attempt now. A registration that has not answered yet gets one
+     * spawn delay before an attempt competes with it.
+     */
+    shouldRecruit(registered: boolean): boolean;
+    add(contender: ServiceContender): void;
+    releaseAll(): void;
+};
+export declare function contenderFinished(contender: ServiceContender): boolean;

package/dist/service-contender.js

@@ -0,0 +1,10 @@
+import {
+  spawnServiceContender2,
+  contenderPool2,
+  contenderFinished2
+} from "./chunks/contract-ve4aws36.js";
+export {
+  contenderFinished2 as contenderFinished,
+  contenderPool2 as contenderPool,
+  spawnServiceContender2 as spawnServiceContender
+};

package/dist/service-probe.d.ts

@@ -0,0 +1,70 @@
+import type { DiscoverOptions, Endpoint, Info } from "./service.js";
+export type LocalService = {
+    readonly info: Info;
+    readonly endpoint: Endpoint;
+    readonly version?: string;
+    readonly state: "ready" | "waiting" | "failed";
+    readonly compatible: boolean;
+};
+/**
+ * What `ensure()` does with a registered service that answered: return it, keep polling while
+ * it starts, replace it because its version does not meet the requirement, or fail.
+ */
+export declare function decide(service: LocalService, options: DiscoverOptions): {
+    readonly _tag: "replace";
+    readonly pty: "clear" | "handoff";
+} | {
+    readonly pty?: undefined;
+    readonly _tag: "reuse";
+} | {
+    readonly pty?: undefined;
+    readonly _tag: "wait";
+} | {
+    _tag: "fail";
+    error: Error;
+};
+/** The default registration file. */
+export declare function fallback(): string;
+/** Whether two registrations describe the same service instance. */
+export declare function same(left: Info, right: Info): boolean;
+/** Ask a registered owner for its health and classify the answer. */
+export declare function probeResult(info: Info, timeout?: number): Promise<{
+    service: undefined;
+    timedOut: boolean;
+} | {
+    service: {
+        info: Info;
+        endpoint: {
+            url: string;
+            auth: {
+                type: "basic";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        version: string | undefined;
+        state: "ready";
+        compatible: false;
+    };
+    timedOut: boolean;
+} | {
+    service: {
+        info: Info;
+        endpoint: {
+            url: string;
+            auth: {
+                type: "basic";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        version: string;
+        state: "failed" | "ready" | "waiting";
+        compatible: true;
+    };
+    timedOut: boolean;
+}>;
+/** Create HTTP authentication headers for a service endpoint. */
+export declare function headers(endpoint: Endpoint): {
+    authorization: string;
+} | undefined;

package/dist/service-probe.js

@@ -0,0 +1,16 @@
+import {
+  decide2,
+  fallback2,
+  same2,
+  probeResult2,
+  headers2
+} from "./chunks/contract-8ye1ye6f.js";
+import"./chunks/contract-xgnj2w4v.js";
+import"./chunks/contract-sxt88q69.js";
+export {
+  decide2 as decide,
+  fallback2 as fallback,
+  headers2 as headers,
+  probeResult2 as probeResult,
+  same2 as same
+};

package/dist/service-timing.d.ts

@@ -0,0 +1,12 @@
+export type EnsureTiming = {
+    readonly pollInterval: number;
+    readonly requestTimeout: number;
+    readonly spawnDelay: number;
+    readonly maxSpawnDelay: number;
+    readonly promiseTimeout: number;
+    readonly stopPollInterval: number;
+    readonly stopPollAttempts: number;
+};
+export declare const defaultEnsureTiming: EnsureTiming;
+export declare function ensureTiming(options: object): EnsureTiming;
+export declare function withEnsureTiming<A extends object>(options: A, overrides: Partial<EnsureTiming>): A;

package/dist/service-timing.js

@@ -0,0 +1,10 @@
+import {
+  defaultEnsureTiming2,
+  ensureTiming2,
+  withEnsureTiming2
+} from "./chunks/contract-xgnj2w4v.js";
+export {
+  defaultEnsureTiming2 as defaultEnsureTiming,
+  ensureTiming2 as ensureTiming,
+  withEnsureTiming2 as withEnsureTiming
+};

package/dist/service-version.d.ts

@@ -0,0 +1,2 @@
+import type { DiscoverOptions } from "./service.js";
+export declare function matchesVersion(version: string | undefined, options: DiscoverOptions): boolean;

package/dist/service-version.js

@@ -0,0 +1,6 @@
+import {
+  matchesVersion2
+} from "./chunks/contract-sxt88q69.js";
+export {
+  matchesVersion2 as matchesVersion
+};