@treeseed/treedx 0.1.1

package/dist/treedx/adapters/policy.d.ts

@@ -0,0 +1,9 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class PolicyAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    capabilities(): Promise<unknown>;
+    grants(query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    createGrant(input: unknown): Promise<unknown>;
+    refresh(input?: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/policy.js

@@ -0,0 +1,11 @@
+import { jsonRequest } from './common.js';
+export class PolicyAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    capabilities() { return jsonRequest(this.context.transport, 'GET', '/api/v1/policy/capabilities'); }
+    grants(query) { return jsonRequest(this.context.transport, 'GET', '/api/v1/policy/grants', undefined, query); }
+    createGrant(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/policy/grants', input); }
+    refresh(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/policy/refresh', input); }
+}

package/dist/treedx/adapters/query.d.ts

@@ -0,0 +1,9 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class QueryAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    readFile(repoId: string, input: unknown): Promise<unknown>;
+    listPaths(repoId: string, input: unknown): Promise<unknown>;
+    searchFiles(repoId: string, input: unknown): Promise<unknown>;
+    repository(repoId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/query.js

@@ -0,0 +1,11 @@
+import { jsonRequest, segment } from './common.js';
+export class QueryAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    readFile(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/files/read`, input); }
+    listPaths(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/paths/list`, input); }
+    searchFiles(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/files/search`, input); }
+    repository(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/query`, input); }
+}

package/dist/treedx/adapters/registry.d.ts

@@ -0,0 +1,9 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class RegistryAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    localNode(): Promise<unknown>;
+    nodes(): Promise<unknown>;
+    getPlacement(repoId: string): Promise<unknown>;
+    setPlacement(repoId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/registry.js

@@ -0,0 +1,11 @@
+import { jsonRequest, segment } from './common.js';
+export class RegistryAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    localNode() { return jsonRequest(this.context.transport, 'GET', '/api/v1/node'); }
+    nodes() { return jsonRequest(this.context.transport, 'GET', '/api/v1/registry/nodes'); }
+    getPlacement(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/registry/repos/${segment(repoId)}/placement`); }
+    setPlacement(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/registry/repos/${segment(repoId)}/placement`, input); }
+}

package/dist/treedx/adapters/repositories.d.ts

@@ -0,0 +1,14 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class RepositoriesAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    register(input: unknown): Promise<unknown>;
+    list(): Promise<unknown>;
+    create(input: unknown): Promise<unknown>;
+    get(repoId: string): Promise<unknown>;
+    status(repoId: string): Promise<unknown>;
+    refs(repoId: string): Promise<unknown>;
+    remotes(repoId: string): Promise<unknown>;
+    push(repoId: string, input?: unknown): Promise<unknown>;
+    sync(repoId: string, input?: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/repositories.js

@@ -0,0 +1,16 @@
+import { jsonRequest, segment } from './common.js';
+export class RepositoriesAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    register(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/repos/register', input); }
+    list() { return jsonRequest(this.context.transport, 'GET', '/api/v1/repos'); }
+    create(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/repos', input); }
+    get(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}`); }
+    status(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/status`); }
+    refs(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/refs`); }
+    remotes(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/remotes`); }
+    push(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/push`, input); }
+    sync(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/sync`, input); }
+}

package/dist/treedx/adapters/search-index.d.ts

@@ -0,0 +1,8 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class SearchIndexAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    status(repoId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    refresh(repoId: string, input?: unknown): Promise<unknown>;
+    compact(repoId: string, input?: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/search-index.js

@@ -0,0 +1,10 @@
+import { jsonRequest, segment } from './common.js';
+export class SearchIndexAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    status(repoId, query) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/search/index/status`, undefined, query); }
+    refresh(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/search/index/refresh`, input); }
+    compact(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/search/index/compact`, input); }
+}

package/dist/treedx/adapters/snapshots.d.ts

@@ -0,0 +1,7 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class SnapshotsAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    build(repoId: string, input: unknown): Promise<unknown>;
+    get(repoId: string, snapshotId: string): Promise<unknown>;
+}

package/dist/treedx/adapters/snapshots.js

@@ -0,0 +1,9 @@
+import { jsonRequest, segment } from './common.js';
+export class SnapshotsAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    build(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/snapshots/build`, input); }
+    get(repoId, snapshotId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/snapshots/${segment(snapshotId)}`); }
+}

package/dist/treedx/adapters/workspaces.d.ts

@@ -0,0 +1,8 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class WorkspacesAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    create(repoId: string, input: unknown): Promise<unknown>;
+    get(workspaceId: string): Promise<unknown>;
+    close(workspaceId: string, input?: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/workspaces.js

@@ -0,0 +1,10 @@
+import { jsonRequest, segment } from './common.js';
+export class WorkspacesAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    create(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/workspaces`, input); }
+    get(workspaceId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/workspaces/${segment(workspaceId)}`); }
+    close(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/close`, input); }
+}

package/dist/treedx/client/TreeDxClient.d.ts

@@ -0,0 +1,41 @@
+import { AdminAdapter, ArtifactsAdapter, AuditAdapter, BlobsAdapter, ContextAdapter, ExecAdapter, FederationAdapter, FederationInternalAdapter, FilesAdapter, GraphAdapter, MigrationsAdapter, MirrorsAdapter, ObservabilityAdapter, PolicyAdapter, QueryAdapter, RegistryAdapter, RepositoriesAdapter, SearchIndexAdapter, SnapshotsAdapter, WorkspacesAdapter } from '../adapters/index.js';
+import { type TreeDxOpenApiMethod, type TreeDxOpenApiPath } from '../generated/index.js';
+import type { BinaryBody, TreeDxClientConfig, Transport } from '../types/index.js';
+export declare class TreeDxClient {
+    readonly config: TreeDxClientConfig;
+    readonly transport: Transport;
+    readonly repositories: RepositoriesAdapter;
+    readonly workspaces: WorkspacesAdapter;
+    readonly files: FilesAdapter;
+    readonly blobs: BlobsAdapter;
+    readonly query: QueryAdapter;
+    readonly graph: GraphAdapter;
+    readonly context: ContextAdapter;
+    readonly federation: FederationAdapter;
+    readonly registry: RegistryAdapter;
+    readonly snapshots: SnapshotsAdapter;
+    readonly artifacts: ArtifactsAdapter;
+    readonly mirrors: MirrorsAdapter;
+    readonly migrations: MigrationsAdapter;
+    readonly exec: ExecAdapter;
+    readonly observability: ObservabilityAdapter;
+    readonly admin: AdminAdapter;
+    readonly audit: AuditAdapter;
+    readonly policy: PolicyAdapter;
+    readonly searchIndex: SearchIndexAdapter;
+    readonly federationInternal: FederationInternalAdapter;
+    constructor(config: TreeDxClientConfig);
+    health(): Promise<unknown>;
+    version(): Promise<unknown>;
+    whoami(): Promise<unknown>;
+    effectiveScope(): Promise<unknown>;
+    authMode(): Promise<unknown>;
+    createDevToken(input?: unknown): Promise<unknown>;
+    operation<T = unknown>(method: TreeDxOpenApiMethod, path: TreeDxOpenApiPath, options?: {
+        pathParams?: Record<string, string | number>;
+        query?: Record<string, string | number | boolean | undefined>;
+        body?: unknown;
+        binaryBody?: BinaryBody;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+}

package/dist/treedx/client/TreeDxClient.js

@@ -0,0 +1,83 @@
+import { AdminAdapter, ArtifactsAdapter, AuditAdapter, BlobsAdapter, ContextAdapter, ExecAdapter, FederationAdapter, FederationInternalAdapter, FilesAdapter, GraphAdapter, MigrationsAdapter, MirrorsAdapter, ObservabilityAdapter, PolicyAdapter, QueryAdapter, RegistryAdapter, RepositoriesAdapter, SearchIndexAdapter, SnapshotsAdapter, WorkspacesAdapter } from '../adapters/index.js';
+import { TREEDX_OPENAPI_OPERATIONS } from '../generated/index.js';
+import { FetchTransport } from './transport.js';
+export class TreeDxClient {
+    config;
+    transport;
+    repositories;
+    workspaces;
+    files;
+    blobs;
+    query;
+    graph;
+    context;
+    federation;
+    registry;
+    snapshots;
+    artifacts;
+    mirrors;
+    migrations;
+    exec;
+    observability;
+    admin;
+    audit;
+    policy;
+    searchIndex;
+    federationInternal;
+    constructor(config) {
+        this.config = config;
+        this.transport = config.transport ?? new FetchTransport(config);
+        const adapterContext = { transport: this.transport };
+        this.repositories = new RepositoriesAdapter(adapterContext);
+        this.workspaces = new WorkspacesAdapter(adapterContext);
+        this.files = new FilesAdapter(adapterContext);
+        this.blobs = new BlobsAdapter(adapterContext);
+        this.query = new QueryAdapter(adapterContext);
+        this.graph = new GraphAdapter(adapterContext);
+        this.context = new ContextAdapter(adapterContext);
+        this.federation = new FederationAdapter(adapterContext);
+        this.registry = new RegistryAdapter(adapterContext);
+        this.snapshots = new SnapshotsAdapter(adapterContext);
+        this.artifacts = new ArtifactsAdapter(adapterContext);
+        this.mirrors = new MirrorsAdapter(adapterContext);
+        this.migrations = new MigrationsAdapter(adapterContext);
+        this.exec = new ExecAdapter(adapterContext);
+        this.observability = new ObservabilityAdapter(adapterContext);
+        this.admin = new AdminAdapter(adapterContext);
+        this.audit = new AuditAdapter(adapterContext);
+        this.policy = new PolicyAdapter(adapterContext);
+        this.searchIndex = new SearchIndexAdapter(adapterContext);
+        this.federationInternal = new FederationInternalAdapter(adapterContext);
+    }
+    health() {
+        return this.observability.health();
+    }
+    version() {
+        return this.transport.request({ method: 'GET', path: '/api/v1/version' }).then((response) => response.data);
+    }
+    whoami() {
+        return this.transport.request({ method: 'GET', path: '/api/v1/auth/whoami' }).then((response) => response.data);
+    }
+    effectiveScope() {
+        return this.transport.request({ method: 'GET', path: '/api/v1/policy/effective-scope' }).then((response) => response.data);
+    }
+    authMode() {
+        return this.transport.request({ method: 'GET', path: '/api/v1/auth/mode' }).then((response) => response.data);
+    }
+    createDevToken(input) {
+        return this.transport.request({ method: 'POST', path: '/api/v1/auth/dev-token', body: input }).then((response) => response.data);
+    }
+    operation(method, path, options = {}) {
+        if (!TREEDX_OPENAPI_OPERATIONS.some((operation) => operation.method === method && operation.path === path)) {
+            throw new Error(`Unknown TreeDX OpenAPI operation: ${method} ${path}`);
+        }
+        const resolvedPath = path.replace(/\{([^}]+)\}/g, (_match, key) => {
+            const value = options.pathParams?.[key];
+            if (value === undefined) {
+                throw new Error(`Missing path parameter ${key} for ${method} ${path}`);
+            }
+            return encodeURIComponent(String(value));
+        });
+        return this.transport.request({ method, path: resolvedPath, query: options.query, body: options.body, binaryBody: options.binaryBody, headers: options.headers }).then((response) => response.data);
+    }
+}

package/dist/treedx/client/TreeDxFederatedClient.d.ts

@@ -0,0 +1,7 @@
+import { FederationAdapter } from '../adapters/index.js';
+import type { TreeDxClientConfig, Transport } from '../types/index.js';
+export declare class TreeDxFederatedClient {
+    readonly transport: Transport;
+    readonly federation: FederationAdapter;
+    constructor(config: TreeDxClientConfig);
+}

package/dist/treedx/client/TreeDxFederatedClient.js

@@ -0,0 +1,10 @@
+import { FederationAdapter } from '../adapters/index.js';
+import { FetchTransport } from './transport.js';
+export class TreeDxFederatedClient {
+    transport;
+    federation;
+    constructor(config) {
+        this.transport = config.transport ?? new FetchTransport(config);
+        this.federation = new FederationAdapter({ transport: this.transport });
+    }
+}

package/dist/treedx/client/TreeDxRegistryClient.d.ts

@@ -0,0 +1,7 @@
+import { RegistryAdapter } from '../adapters/index.js';
+import type { TreeDxClientConfig, Transport } from '../types/index.js';
+export declare class TreeDxRegistryClient {
+    readonly transport: Transport;
+    readonly registry: RegistryAdapter;
+    constructor(config: TreeDxClientConfig);
+}

package/dist/treedx/client/TreeDxRegistryClient.js

@@ -0,0 +1,10 @@
+import { RegistryAdapter } from '../adapters/index.js';
+import { FetchTransport } from './transport.js';
+export class TreeDxRegistryClient {
+    transport;
+    registry;
+    constructor(config) {
+        this.transport = config.transport ?? new FetchTransport(config);
+        this.registry = new RegistryAdapter({ transport: this.transport });
+    }
+}

package/dist/treedx/client/auth.d.ts

@@ -0,0 +1,8 @@
+import type { AuthProvider, TreeDxClientConfig } from '../types/index.js';
+export declare class StaticBearerTokenAuthProvider implements AuthProvider {
+    private readonly token;
+    constructor(token: string);
+    getToken(): string;
+}
+export declare function createAuthProvider(tokenOrProvider?: string | AuthProvider): AuthProvider | undefined;
+export declare function resolveAuthorizationHeader(config: Pick<TreeDxClientConfig, 'token' | 'authProvider'>): Promise<Record<string, string>>;

package/dist/treedx/client/auth.js

@@ -0,0 +1,26 @@
+export class StaticBearerTokenAuthProvider {
+    token;
+    constructor(token) {
+        this.token = token;
+    }
+    getToken() {
+        return this.token;
+    }
+}
+export function createAuthProvider(tokenOrProvider) {
+    if (!tokenOrProvider) {
+        return undefined;
+    }
+    if (typeof tokenOrProvider === 'string') {
+        return new StaticBearerTokenAuthProvider(tokenOrProvider);
+    }
+    return tokenOrProvider;
+}
+export async function resolveAuthorizationHeader(config) {
+    const provider = config.authProvider ?? createAuthProvider(config.token);
+    if (!provider) {
+        return {};
+    }
+    const token = await provider.getToken();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+}

package/dist/treedx/client/binary.d.ts

@@ -0,0 +1,4 @@
+import type { BinaryBody } from '../types/index.js';
+export declare function isBinaryBody(value: unknown): value is BinaryBody;
+export declare function assertBinaryBody(value: unknown): asserts value is BinaryBody;
+export declare function toUint8Array(value: BinaryBody): Promise<Uint8Array>;

package/dist/treedx/client/binary.js

@@ -0,0 +1,39 @@
+export function isBinaryBody(value) {
+    return (value instanceof Uint8Array ||
+        value instanceof ArrayBuffer ||
+        Buffer.isBuffer(value) ||
+        (typeof ReadableStream !== 'undefined' && value instanceof ReadableStream));
+}
+export function assertBinaryBody(value) {
+    if (!isBinaryBody(value)) {
+        throw new TypeError('Expected a binary-safe body value');
+    }
+}
+export async function toUint8Array(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (Buffer.isBuffer(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    const chunks = [];
+    const reader = value.getReader();
+    while (true) {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        chunks.push(result.value);
+    }
+    const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return combined;
+}

package/dist/treedx/client/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class TreeDxApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown;
+    readonly payload?: unknown;
+    readonly cause?: unknown;
+    constructor(input: {
+        status: number;
+        code: string;
+        message: string;
+        details?: unknown;
+        payload?: unknown;
+        cause?: unknown;
+    });
+    static fromResponse(status: number, payload: unknown): TreeDxApiError;
+    static network(message: string, cause?: unknown): TreeDxApiError;
+}

package/dist/treedx/client/errors.js

@@ -0,0 +1,35 @@
+export class TreeDxApiError extends Error {
+    status;
+    code;
+    details;
+    payload;
+    cause;
+    constructor(input) {
+        super(input.message);
+        this.name = 'TreeDxApiError';
+        this.status = input.status;
+        this.code = input.code;
+        this.details = input.details;
+        this.payload = input.payload;
+        this.cause = input.cause;
+    }
+    static fromResponse(status, payload) {
+        const envelope = payload;
+        const error = envelope?.error;
+        return new TreeDxApiError({
+            status,
+            code: error?.code ?? 'internal_error',
+            message: error?.message ?? `TreeDX request failed with status ${status}`,
+            details: error?.details,
+            payload
+        });
+    }
+    static network(message, cause) {
+        return new TreeDxApiError({
+            status: 0,
+            code: 'network_error',
+            message,
+            cause
+        });
+    }
+}

package/dist/treedx/client/index.d.ts

@@ -0,0 +1,8 @@
+export * from './TreeDxClient.js';
+export * from './TreeDxRegistryClient.js';
+export * from './TreeDxFederatedClient.js';
+export * from './transport.js';
+export * from './errors.js';
+export * from './auth.js';
+export * from './pagination.js';
+export * from './binary.js';

package/dist/treedx/client/index.js

@@ -0,0 +1,8 @@
+export * from './TreeDxClient.js';
+export * from './TreeDxRegistryClient.js';
+export * from './TreeDxFederatedClient.js';
+export * from './transport.js';
+export * from './errors.js';
+export * from './auth.js';
+export * from './pagination.js';
+export * from './binary.js';

package/dist/treedx/client/pagination.d.ts

@@ -0,0 +1,4 @@
+import type { TreeDxPage } from '../types/index.js';
+export declare function createPage<T>(input: TreeDxPage<T>): TreeDxPage<T>;
+export declare function isTreeDxPage(value: unknown): value is TreeDxPage<unknown>;
+export declare function getNextCursor<T>(page: TreeDxPage<T>): string | undefined;

package/dist/treedx/client/pagination.js

@@ -0,0 +1,15 @@
+export function createPage(input) {
+    return {
+        items: input.items,
+        nextCursor: input.nextCursor,
+        hasMore: input.hasMore,
+        cursor: input.cursor,
+        limit: input.limit
+    };
+}
+export function isTreeDxPage(value) {
+    return typeof value === 'object' && value !== null && Array.isArray(value.items);
+}
+export function getNextCursor(page) {
+    return page.nextCursor;
+}

package/dist/treedx/client/transport.d.ts

@@ -0,0 +1,15 @@
+import type { TreeDxClientConfig, TreeDxRequest, TreeDxResponse, Transport } from '../types/index.js';
+export type TreeDxFetch = typeof fetch;
+export interface FetchTransportOptions {
+    baseUrl: string;
+    defaultHeaders?: Record<string, string>;
+    token?: string;
+    authProvider?: TreeDxClientConfig['authProvider'];
+    fetchImpl?: TreeDxFetch;
+}
+export declare class FetchTransport implements Transport {
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: FetchTransportOptions);
+    request<T = unknown>(request: TreeDxRequest): Promise<TreeDxResponse<T>>;
+}

package/dist/treedx/client/transport.js

@@ -0,0 +1,61 @@
+import { resolveAuthorizationHeader } from './auth.js';
+import { TreeDxApiError } from './errors.js';
+export class FetchTransport {
+    options;
+    fetchImpl;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async request(request) {
+        const url = new URL(request.path, this.options.baseUrl);
+        for (const [key, value] of Object.entries(request.query ?? {})) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const authHeaders = await resolveAuthorizationHeader(this.options);
+        const headers = {
+            ...this.options.defaultHeaders,
+            ...authHeaders,
+            ...request.headers
+        };
+        let body;
+        if (request.binaryBody) {
+            body = request.binaryBody;
+        }
+        else if (request.body !== undefined) {
+            headers['Content-Type'] ??= 'application/json';
+            body = JSON.stringify(request.body);
+        }
+        let response;
+        try {
+            response = await this.fetchImpl(url, { method: request.method, headers, body });
+        }
+        catch (error) {
+            throw TreeDxApiError.network('TreeDX network request failed', error);
+        }
+        const data = await parseResponseBody(response);
+        if (!response.ok) {
+            throw TreeDxApiError.fromResponse(response.status, data);
+        }
+        return {
+            status: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            data: data
+        };
+    }
+}
+async function parseResponseBody(response) {
+    if (response.status === 204) {
+        return undefined;
+    }
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('application/json')) {
+        return response.json();
+    }
+    if (contentType.startsWith('text/')) {
+        return response.text();
+    }
+    return response.arrayBuffer();
+}

package/dist/treedx/conformance/adapter.d.ts

@@ -0,0 +1,28 @@
+import type { TreeDxClient } from '../client/TreeDxClient.js';
+export interface TreeDxConformanceAdapterOptions {
+    client: TreeDxClient;
+    serverConfigured?: boolean;
+}
+export interface TreeDxConformanceScenario {
+    id: string;
+    capabilityId: string;
+    title: string;
+    required: boolean;
+    endpointRefs: string[];
+    steps: Array<{
+        name: string;
+        action: string;
+        description: string;
+    }>;
+    assertions: string[];
+}
+export interface TreeDxConformanceResult {
+    scenarioId: string;
+    status: 'passed' | 'failed' | 'not_configured';
+    message?: string;
+}
+export declare class TreeDxConformanceAdapter {
+    private readonly options;
+    constructor(options: TreeDxConformanceAdapterOptions);
+    runScenario(scenario: TreeDxConformanceScenario): Promise<TreeDxConformanceResult>;
+}